Accountable platform owners
You answer for what your agents commit to.
You remain answerable to your board and to counterparties for every agent commitment — yet you have no enforced control before those commitments bind. Subchain sets that control where authority already sits.
Authority first
Authority set before any agent transacts.
For the person who owns the estate and carries the risk, the controls are yours to configure, not ours to assume.
Thresholds you own
The limits that decide what binds automatically and what waits for you are yours to set, review and evidence — not defaults we choose on your behalf.
A named person clears it
Authority to bind stays with an accountable human governor you nominate, so a board or a counterparty can always see who authorised a given commitment.
Configured once
Adding a counterparty is a single integration to the standard, not another point-to-point connector to build, own and maintain as relationships grow.
Answerable, not automated away
The runtime surfaces exceptions for a person to resolve rather than resolving them unilaterally, so accountability stays with someone who can answer for it.
What you control, and what your agents execute.
Bounded agent autonomy
You set authority limits, value, risk and irreversibility thresholds, and approval routing before any negotiation runs. Your agents execute inside those rules and cannot widen their own mandate.
The approval gate
When a proposed commitment exceeds a threshold or reads as policy-ambiguous, the runtime stops and routes it to the accountable governor. It cannot bind until that person explicitly signs off, and the decision is logged.
One integration per counterparty
A new counterparty connects once to the protocol instead of through a bespoke build. From that single connection it can transact with any other adopting party, so integration cost stops scaling with each relationship.
A deterministic lifecycle
Offer, counter and acceptance follow one deterministic state machine with tracked state. Failures are reproducible and states do not drift silently between counterparties, so your engineers build against a lifecycle rather than reconstructed message formats.
The argument
What binds, what waits, and what we are honest about.
What actually binds
Your agents run offer-counter exchanges against one standard. Terms that sit inside every limit you configured, and pass the inline checks, are recorded as accepted and the agreement binds. Anything above a value, risk or irreversibility threshold does not bind. It halts, and routes to the named governor you nominated. Until that person approves, there is no commitment — only a proposal on the record.
This is the distinction the accountable owner needs in plain terms. Autonomy is real, but it is bounded by rules you own. The high-value, irreversible or ambiguous commitment — the one you would lose sleep over — is precisely the one the runtime will not let bind on its own.
The accountability most estates lack
Two gaps show up as an agent estate grows. Most organisations cannot name who is accountable for what their agents commit to — 85% report no formal accountability. And cross-company agent activity largely runs outside monitoring: only 17% continuously monitor agent-to-agent interactions. Subchain is built against both gaps by design — a named governor attached to each material commitment, and a complete record of every exchange rather than a sample taken afterwards.
What we are honest about
We are direct about the open question, because you should weigh it. The integration cost is something we observe plainly in agent-deploying estates. The appetite for governing negotiation as its own layer is something we are still working with early partners to establish. We would rather say so than overstate the case. Subchain is an early Cohort Ventures venture, domiciled in the DIFC, and we are candid about where the evidence is thin and where it is firm.
What an accountable owner asks first.
Set the gate before your agents commit.
Bring your counterparty load and the thresholds you would want enforced. A named person on the team will map them to the runtime and be honest about what is proven.