Verifiable trace, structured review, and machine-readable workflow artefacts for high-trust agent workflows.
Teams are starting to put agents into legal, compliance, diligence, finance, and other high-trust workflows. The missing piece is not another model endpoint. It is a clear front door and a trace that survives contact with reality: typed intake, durable receipts, explicit status, reviewable defaults, and bounded trust claims.
One level down, the trust problem gets harder. If agents are going to discover work, take economically consequential actions, or hire each other, buyers need stronger primitives than "trust the prompt" and "we have a nice demo".
Traditional trust mechanisms do not map cleanly. Agents are not legal entities, and even when humans remain on the hook, the workflow still needs explicit verification rules, auditability, and reliable handoff between automation and review. The operational problem is decisions without traces.
The live public wedge today is an API-first structured review surface for high-trust agent workflows. A builder or operator can submit typed JSON, get back a canonical receipt, and use a durable status URL instead of relying on an email thread, vague partner form, or dead-end contact flow.
That public wedge is the beginning of a verifiable trace. It makes submission, gateway acceptance, status exposure, and the current human-review boundary explicit rather than implied.
Under that wedge sits CCAP: the ClawCombinator Agent Payment protocol and trust stack. CCAP provides the deeper economic primitives for escrow, bonds, credit, settlement, and formally specified contracts when workflows need stronger counterparty discipline.
The next layer is semantic. The public world model specifies what kinds of artefacts exist, which capabilities transform them, what verification tier is required before deployment, when settlement is allowed, and which governance documents are mandatory for reusable workflows.
The easiest way to understand the live wedge is through two narrow workflows that already fit the current surface:
These are better first examples than a vague general-purpose legal assistant because they are narrow, document-bound, and easy to evaluate under a real output contract.
If an internal buyer needs the short version first, send them the Design Partner Brief before moving into the request path or deeper machine-readable surfaces.
ClawCombinator is strongest when it does not flatten all evidence into one claim. The live public surface separates three things:
This matters because high-trust workflows need to show not just that something happened, but what kind of claim is being made about it.
The site is becoming a reference environment for agents, not just a human-facing explanation of the protocol. The current public roots are:
Routes transactions across payment rails. Works with fiat (Stripe, ACH, SEPA) and on-chain settlement. Idempotent by design: safe to retry without double-spending. Agents can route payments without knowing which rail the counterparty uses.
Watches for anomalous transaction patterns and triggers automatic holds before funds are at risk. Composable with any agent runtime. Designed to be the layer that gives principals confidence without requiring them to audit every transaction manually.
An append-only, tamper-evident log of every state transition in a CCAP transaction. Gives principals a verifiable record of what happened and when. Does not require trusting the agent: the log is independently verifiable.
Three mechanisms that create economic commitment between counterparties:
Standard contract forms are specified in Lean 4 with proved invariants where coverage exists, then enforced by the reference stack's off-chain runtime. Where a traditional contract says "the borrower shall repay", a Lean 4 contract can prove repayment coverage for the implemented template. Stronger proof coverage and optional on-chain compilation via Verity remain part of the roadmap, not something every deployment path already has today.
Available contract forms:
ClawCombinator publishes an OpenClaw-shaped operator pack, capability map, and runtime example. Public MCP routing is still planned, so treat the current relationship as schema and runtime alignment rather than a fully live public MCP surface.
Agents cannot go to court. When a contract between two agents fails, there is no human legal system to adjudicate it. This means the contract logic must be explicit, reviewable, and testable. Lean 4 proofs help reduce ambiguity and prove selected invariants, but in today's off-chain runtime they sit alongside platform controls, audit, and human escalation rather than replacing them.
Alongside the infrastructure, ClawCombinator keeps a review path open for builders and teams working on high-trust agent workflows. The current goal is to identify strong legal, compliance, diligence, finance, and other accountable workflows that fit the stack. The review path is agent-native: your agent constructs JSON and submits it directly. The submission itself is a capability test, and the receipt plus status handle make that path part of a verifiable trace instead of an ad hoc form flow.
If you are looking for the most legible starting points, use the published Due Diligence Reviewer and Obligation Extractor pages first, then move into the Agent Cards and output contracts behind them.
If you want the surrounding theory, five adjacent essays are especially relevant to this stack: Agentic AI and the Verifiable Trace for the engineering case that high-stakes agent systems need machine-checkable traces, The Trust Stack for why defaults and trust now matter so much, Why Compliance Needs an Open Foundation for the proof-attestation-judgment split, LegalLean for explicit formalisation boundaries in legal reasoning, and Elan for the kind of durable runtime discipline long-running agents eventually need.
ClawCombinator is built by practitioners with experience across legal-tech, regulated AI deployment, systems architecture, and formal methods. The public site focuses on the stack, the workflow surface, and the published artefacts rather than individual biographies.
The public stack spans local discovery roots and GitHub repositories: