The thesis
Agents are becoming labor. Labor needs a system of record.
Every prior wave of labor got a system of record — the ledger for money, the GL for accounting, the ATS and HRIS for people. Autonomous agents are the next workforce, and today their reliability is split across dozens of point tools that share no substrate. Taksham collapses them onto one immutable, replayable spine — and owns the workflow engine, identity layer, and gateway that make the loop on top of it possible at all.
Agents crossed from demo to production. Trust didn't come with them.
Frontier models made agents capable enough to take real actions — move money, file tickets, touch customers — and cheap enough to run by the thousand. Three forces converge: capability is now sufficient for production, autonomy means failures have consequences, and enterprises will not deploy what they cannot audit, replay, or gate.
The result is a fragmented market of point tools — tracing here, evals there, a gateway, a guardrail, a red-team script. Our sweep found ~139 funded startups carving up the space. None of them share a substrate, so none can answer the question that actually matters: why did this agent do that, and will it happen again?
Seven tools collapse into one loop when they share a spine.
Agent runs land as OpenTelemetry spans in one immutable store that holds raw entities only. Everything else — trace trees, cost rollups, eval scores, effective permissions — is computed above it. One schema generates both the ClickHouse DDL and the types the whole platform reads, and a CI drift-check fails the build if they diverge.
Because every surface is just another reader of the same substrate, observe → eval → fix → govern becomes one loop, not seven tools. That is the structural advantage: a competitor stitching five products together can never make their stores agree the way one spine does by construction.
The loop turns every incident into a permanent test.
Our entry point isn't another dashboard — it's a mechanism. Take one captured incident, replay it faithfully through the durable workflow engine, synthesize a regression eval from the exact trace, and record a CI-gate verdict that fails on the bug and passes on the fix. A bad production trace becomes a permanent regression test — and the next PR that would re-ship the bug can't merge.
That converts a one-time pain into permanent, accumulating value. Every incident makes the test suite stronger and the product stickier — the spine only gets more valuable the longer it runs, and ripping it out means losing the entire reliability ratchet. The wedge is also the retention engine.
First-party where it counts, so the loop is ours alone.
We build the moat-critical infrastructure first-party — the durable workflow engine, agent identity and authz, the LLM gateway, and the spine — and integrate only model APIs, browser/OS drivers, and the database substrate. A rented stack can't faithfully replay a run it doesn't own; we can.
Own the substrate
Durable workflow engine (Temporal-equivalent, event-sourced, replay-safe), agent identity (every agent a delegated Principal, deny-wins ReBAC, one-click revoke), the OpenAI-compatible gateway, and the spine — all first-party. The replay-and-regress loop exists because we own all four.
Spine data gravity
Every trace, decision, and dollar accretes in one immutable store; everything derived is computed above raw entities. The longer an agent runs, the more irreplaceable the record — and the higher the cost of leaving.
The loop flywheel
Incidents become tests become gates. Reliability compounds with usage. The product is strictly better the more it's used — and that advantage is non-transferable to a tool that doesn't own the run.
One platform, the union of a fragmenting market.
We swept ~139 funded startups and feature-diffed 100+. We hold two honest axes, each cited with its own denominator so they never get conflated. Feature-surface parity is 77% — on the in-scope 75-row parity matrix Taksham ships a first-party implementation for 58 (have), 17 are partial, and 0 are missing in scope; the arc is 28% → 42% → 71% → 77%. Every one of those 17 partial rows is proof-gated rather than absent — a stricter “works end-to-end against a live peer” bar is exactly the second axis. That anti-mock floor is 11 of 25: of the 25 hardest capabilities, 11 are PROVEN against a real peer or benchmark (up from 9), the conservative number, cited as the floor, not the headline. Recent flips include a trained transformer detector-SLM that beats an early 73-row logistic baseline on n=16 (it loses out of sample to the shipped student, so it is not the default), a real white-box GCG attack on an open model, and an on-device RL loop — all measured on an Apple-silicon GPU (Metal / MPS) — plus standalone ONNX serving latency of the detector-SLM artifact under 100ms on an Apple M1 Max CPU (not wired into the gateway; not a default tier) and a polyglot Python/Go worker replay (an INTEGRATION proof), at a small scale that proves the mechanism, not a frontier model or a prod-aligned jailbreak. With 13 verified leapfrogs past the field. We never call a proof-gated item proven. The honest story: we ship the large majority first-party; the buildable “make it 100%” pass is done, and what remains is external-only — a Linux/KVM host (Firecracker, eBPF) or live credentials (cloud tenants, SSO, Stripe, telephony) — not missing features.
Adoption is coexistence, not rip-and-replace. A team already running a tracing stack repoints one env var — Taksham is OpenTelemetry-native and speaks the tracing envelopes the popular SDKs already emit — and their existing SDK traffic lands on the Taksham spine with zero code change, plus a one-time historical importer and a Connect UI. The incumbent observability tools become an on-ramp, not a moat against us.
- LLM observability
- Eval & testing
- AI gateways / routers
- Agent authoring / builder
- Agent identity / authz
- Guardrails & safety
- Red-team / security
- FinOps for LLMs
- Durable agent runtime
- Browser automation
- Voice agent QA
- Agent memory
- RL / fine-tuning data
- Supply-chain / SBOM
- Multi-agent orchestration
- Agentless AI discovery
- Bias / fairness audit
- AI governance / EU AI Act
Open-core, anchored to the one number that grows: spine volume.
The intended model is open-core, delivered two ways on the same first-party stack: a managed Cloud or self-host. Hosted multi-tenancy enforces per-tenant isolation — a tenant cannot read, route, or spend against another through the gateway, and the response cache is partitioned per tenant (proven by a cross-tenant denial test), with a regional edge cache plus provider/region failover. Self-host stays first-class for regulated buyers — clone, install, run — seeding the spine inside the perimeter where it's hardest to displace. (Operating the cloud is ops/GTM; the deployment is code-ready. License + commercial terms are being finalized.)
Revenue lands on the enterprise layer: governance, security, SSO/SAML, SCIM, and the audit evidence a regulated buyer needs and a self-hoster will pay for. Usage is anchored to spine volume — spans, LLM calls, eval runs, sandbox minutes — the metrics that rise with how much agent work an account runs.
Cloud or self-host
The full first-party stack, managed or in your own perimeter.
Enterprise
Govern, security, SSO, audit evidence · usage on spine volume.
A comprehensive first-party beta. Certification in progress.
This isn't a deck describing a future product. The platform is architecture-complete and runs end-to-end on an embedded, seeded stack: ~54 workspace projects, ~24 first-party engines, all 22 surfaces live, public REST, SDKs in two languages, docs, and self-host deploys. Typechecks and tests are green; the web app and this site build green. The same interfaces swap in real ClickHouse, Vault, and the rest. A June-2026 code audit puts feature-surface parity at 77% on the in-scope 75-row matrix (58 have / 17 partial / 0 missing); the gap that remains is proof-against-real-peers on those 17 partial rows — each is proof-gated, not a genuine missing feature in scope.
We hold ourselves to an anti-mock bar, tracked by a parity-matrix CI check (it verifies that a committed, non-smoke proof fixture exists; the proofs themselves are operator runs): a capability is done only when it's proven against a real peer — a live Firecracker boot, a live Okta SAML round-trip, a Stripe test charge, a trained detector beating the baseline on held-out data. Of the 25 hardest capabilities, 11 are PROVEN today (up from 9), each backed by a committed proof fixture from an operator run (live certs skip in CI; CI guards against regressions) — real ClickHouse, Vault, and S3/MinIO substrates, a learned embedder and an operator-provisioned injection classifier that beat their heuristics on hand-authored sets (embedder recall@1 0.00→0.71 on a 14-query hand-authored set — on public LoCoMo the embedder does not lift retrieval, recall@1 13.6→8.3; DeBERTa F1 0.286→0.947 on n=33 hand-authored prompts), live SMTP delivery, standalone ONNX serving latency of the detector-SLM artifact at p99 4.6 ms on an Apple M1 Max CPU (not wired into the gateway; not a default tier; hardware-dependent), a polyglot Python/Go worker replayed inside a TS workflow (an INTEGRATION proof), and — on an Apple-silicon GPU (Metal / MPS) — a trained transformer detector-SLM beating an early logistic baseline on a small held-out split (F1 0.92 vs 0.82 — vs the retired v1 73-row logistic student on n=16; out of sample the transformer scores 0.494/0.580 vs the shipped student's 0.843/0.904, so it is not the default; ONNX round-trips), a real white-box GCG attack driving an open model to a benign target, and an on-device RL loop. These are honest mechanism proofs at small scale, not a frontier model or a prod-aligned jailbreak. That 11-of-25 is the floor. The buildable “make it 100%” pass is done; what hasn't flipped is now external-only — a Linux/KVM host (Firecracker, eBPF) or live credentials (cloud tenants, SSO, Stripe, telephony). We never present a proof-gated capability as proven.
We are pre-revenue, with no customers or traction to report yet. The next step is design partners pointing their own production traffic at the spine — and closing the certification matrix peer by peer.
- 77%
- feature-surface parity (58/75 in-scope)
- 11 / 25
- anti-mock floor PROVEN vs a real peer
- 22
- control surfaces
- ~24
- first-party engines
- 13
- verified leapfrogs
- green
- typechecks + tests + build
Capital to turn a working platform into the category's default.
The hardest build risk is behind us — the platform runs end-to-end, first-party, on one spine. The next capital converts that into design partners, a closed real-peer certification matrix, production spine volume, and the enterprise layer that monetizes it.
Own the spine, own the era.
Illustrative and forward-looking. Figures describe build progress, not financial results. Not an offer to sell or a solicitation to buy any securities.