DROP-IN PROXY - NO SDK REWRITE
Point your OpenAI and Anthropic calls at Kolm - your SDK stays exactly as it is. Kolm captures the behavior you already use, compiles it into a signed model in one portable file, and runs it on your own hardware. Pay to run the behavior you've already established - not frontier prices to rent it again, forever.
Running today
What you get
Most tools stop at a demo, a dashboard, or a gateway. Kolm carries the whole job - capture your behavior, set the rules, test it, compile it, run it anywhere, and hand you proof.
Point your traffic at Kolm and it records the calls you make - structured, messy, or unknown alike. Where each capture came from, its source hash, environment, and retention window travel with it, ready to open on any record later.
Redact sensitive fields, set data boundaries, scope exports, cap budgets, and purge what you don't want. Every captured call passes through a policy gate (a single checkpoint your rules run at)A policy gate is the one checkpoint every captured call must pass before it can be reused. Your redaction, retention, and export rules run there, so nothing becomes training or eval material until it clears the rules you set. before it can become training or eval material.
Labels, regressions, and failures become evals with thresholds and owners - and they block a release until the behavior you care about passes.
Your behavior and its eval constraints compile into a single artifact - model, manifest, checksums, runtime target, and a receipt anyone can verify.
Hosted, local, your private cloud, edge, offline, or a restricted fleet - pick the smallest runtime that fits, with the limits shown up front.
Receipts, eval reports, audit events, warehouse exports, webhooks, and CI status - all carrying the same IDs, so your trust story holds up when someone checks it.
Manage API keys, roles, environments, provider policy, cost and rate limits, retention, and export destinations - and see connector health at a glance.
Inbound APIs, webhooks, streams, batches, queues, object storage, warehouses, and CLI imports come in; signed artifacts and proof go out.
The data boundary
Every captured call enters one workspace, passes the policy gate once, and only then reaches your dataset, evals, compile, and exports. Nothing crosses the tenant perimeter, and nothing skips the gate.
Takes your live calls in as raw records, each tagged with source and timestamp.
raw recordsource + timestampRedaction, retention, and export scope run here before anything moves on. Nothing skips the gate.
redaction + scopeappliedOnly ever sees records that already cleared the gate.
governedtenant-scopedOnly ever sees records that already cleared the gate.
gradedbehind perimeterOnly ever sees records that already cleared the gate.
one .kolminside perimeterLeaves the perimeter only with the scope the gate allowed, carrying its own receipt.
scoped+ receiptThe artifact
Compile produces a single signed .kolm model: your distilled behavior, the exact build recipe, the eval gates it cleared, and a receipt. Plain terms, no jargon - and the full layout lives in the .kolm spec.
The .kolm model is data you hold, not a subscription. Export it any time and run it with no provider to call and no per-token bill - own the AI you're renting.
Model, recipe, evals, and receipt are bound under one signature with sha256 checksums. Anyone can verify it offline without trusting us or being online.
One artifact, many targets. The same file moves from laptop to edge to server with its IDs and receipts intact - see the ranked runtime targets.
Capture
Point one production workflow at Kolm and it starts recording the behavior you already run. You set up the workspace, key, connector, and retention rules once; from then on, every call you make is captured cleanly and ready to reuse.
Compile
Redact sensitive fields, set data boundaries, scope exports, and cap budgets before anything is reused. Then your edge cases earn their keep: labels, drift checks, thresholds, and locked regression sets decide whether the model is good enough to ship.
Compose
Every capture, rule, eval, compile, runtime, and export is a real record you can query - pull up any claim and see exactly what backs it and where it came from. Every record is tenant-scoped (walled off to one workspace)A tenant is one isolated workspace, usually one team or customer. Tenant-scoped means a record belongs to exactly one tenant and is never visible to, or mixed with, another. One team's captures cannot leak into another team's datasets., so one team's data never bleeds into another's.
Deploy
Deploy to hosted, local, your private cloud, edge, offline, or a restricted fleet - each with its compatibility and limits shown up front. Then the proof leaves with you: receipts, eval reports, webhooks, warehouse exports, and CI status all carry the same IDs, so any team can trace a model end to end from its own tools.
Connects to your stack
Capture from where your behavior already lives, take in calls the way you already send them, and export what you own in the format your team uses.
Provider logs, application events, gateway records, agent tool calls, observability spans, eval data, human labels, product analytics, warehouses, CI/CD, repositories, support tools, GRC systems, files, runtime telemetry, cost events, and customer-system actions.
REST, GraphQL, gRPC, webhooks, streaming, batch files, object storage, warehouse queries, queues, browser events, local CLI, and custom adapter manifests.
Signed model, verifier receipt, eval report, proof bundle, JSON API, warehouse export, webhook, CI status, SIEM/GRC event, and admin analytics.
Register a source, capture a call, classify it, redact what's sensitive, build an eval, lock a regression set, compile the model, and export your proof.
What you can rely on
These are the guarantees behind every capture, model, and export - the kind of detail that decides whether your security and platform teams trust what you ship.
Every change leaves an audit trail you can query and export: what changed, who did it, where, under which policy, and exactly when.
Models, receipts, reports, and exports each carry their source hashes, output hashes, versions, and owner - anyone can re-verify a claim independently, on their own machine.
Every export records its destination, what was sent, the policy that scoped it, delivery status, checksum, and who received it.
Anything unmapped or sensitive is held with its provenance and retention controls - it never gets pulled into a reusable dataset until you classify it.
Benchmark, certification, package, partner, standards, and adoption claims each resolve to a queryable record with its own source, status, and proof you can open.
Hosted, local, your private cloud, edge, offline, or a restricted fleet - each one shows its compatibility, limits, and verification status before you commit.
How Kolm is different
An agent, a gateway, an eval dashboard, or a fine-tuning service each does one piece. Kolm carries your behavior all the way to a portable model on your hardware - with proof.
| If you already use | Here's what Kolm adds | What you keep |
|---|---|---|
| agent tools | Agents get the task done; Kolm captures what they did, gates the failures, and compiles it into a model you can run again cheaply - not just one-off automation. | compare |
| observability | Dashboards explain your behavior. Kolm compiles it into a portable model you own, tested and signed - not just a chart of what happened. | a model |
| model gateways | Routing trims the bill per call. Kolm ends the rent entirely - once your behavior is captured, you run it yourself with no provider to pay. | ownership |
| eval tools | Scores tell you how you're doing. Kolm makes them block a bad release and ship a receipt - your tests gate what goes out. | a gate |
| fine-tuning | Fine-tuning ties you to one provider. Kolm's model, manifest, target, and receipt move with you - switch providers or hardware and it still runs. | no lock-in |
Start with one workflow: capture it, compile it into one signed .kolm model, and run it on your own hardware. Prove it works on one before you scale it across all of them.
Go deeper: the .kolm spec · runtime targets · integrations · pricing · verify offline