For platform providers
Offer governed negotiation without building the runtime yourself.
You build agent infrastructure; your users need a governed way to agree terms with outside counterparties. License the runtime and template library — binding authority stays with a named person, and every step is recorded.
The surface you license and embed.
Deterministic negotiation runtime
An offer, counter and acceptance state machine that tracks status and holds one lifecycle across every counterparty your users reach.
Machine-readable term templates
A versioned library covering scope, service levels, liability and data terms, so agents negotiate against a shared vocabulary rather than free-form text.
Authority limits and approval gates
Configurable checkpoints your customer sets. Anything above their value, risk or irreversibility threshold halts and waits for a named person.
Inline policy-as-code checks
Compliance rules run during negotiation and flag a breaching term before acceptance, moving governance into the exchange itself.
The case for embedding
Why embed the runtime instead of building it.
What building this yourself means
To offer your users governed negotiation, you would otherwise build and maintain several distinct systems yourself. A deterministic state machine that runs offer, counter and acceptance without drifting between counterparties. A versioned library of machine-readable term templates covering scope, service levels, liability and data terms. A configurable approval gate that halts the exchange and routes material commitments to a named person. Inline policy checks that catch a breaching term before it reaches acceptance. And an immutable record that attributes every step to an identity. Each is a product in its own right, and each carries an on-call maintenance load that grows with every counterparty your users add.
The gate is the mechanism, not a feature
The reason this is worth embedding rather than approximating is the gate. In most agent deployments, a high-value or irreversible commitment can bind before any accountable person has seen it. Subchain inverts that: authority limits are set before a negotiation runs, and anything above a customer's threshold stops and waits. The runtime surfaces the exception; it does not resolve it. A named person approves or rejects, and that decision is logged. Autonomous execution stays bounded by rules the customer owns and can evidence — which is what a governance or procurement owner on their side will ask you to prove.
An evidence-quality record
When a settled agreement is later disputed, the question is who proposed what, who approved it, and on whose authority. Subchain answers that by retrieval rather than reconstruction. Every proposal, revision, approval and acceptance is written to an immutable log, producing an ordered account suited to compliance review, audit enquiry and DIFC dispute resolution. Embedding this means your platform carries that record by default, rather than leaving each of your customers to assemble one after the fact.
Boundaries and honesty
What Subchain is, and what it is not.
Name the boundary
Before this is mis-filed: Subchain is a human-governed agreement protocol and runtime. It is not a blockchain, a token or a consensus network, and it is not an autonomous signer. It governs how agents propose and agree terms and where human authority sits over those terms. It does not move money and it does not replace your settlement layer — it sits above agent identity and settlement primitives and below your application-specific workflows.
What we are honest about
We separate what we have seen from what we are still proving. The integration pain around cross-company agent transactions is observed directly. Direct demand for a standalone governed-negotiation layer is inferred from that pain, and signing the first design partners is the work this stage exists to deliver. Some legal questions remain open too: authority-to-bind, liability allocation when an agent errs, and the DIFC-specific treatment of automated contracting require dedicated work before they are relied upon. We will not claim otherwise.
What an agent-platform provider asks first.
Follow the standard as platforms embed it.
Occasional updates on the runtime, the template library and the first design partners — no more than the substance warrants.