Across the Boundary

Share
Across the Boundary
Authority as a narrowing delegation. The prohibited edge is the confused-deputy pattern

Multi-agent operation and the conservation of accountability

Accountability does not diffuse across agents and organisations. What diffuses is knowledge of where it sits — and it is usually recovered during an incident rather than before one.

1. Executive summary

The first two papers in this series assumed a single organisation: one accountable person, one policy engine, one world model, one set of limits. Most of the interesting work in industrial operations does not stay inside that boundary. A sourcing workflow reaches suppliers. A logistics workflow reaches carriers and terminals. A maintenance workflow reaches contractors and original equipment manufacturers. Increasingly, the party on the other end is not a person reading an email but another organisation's agent.

Two quite different problems are routinely discussed as one, and separating them is the precondition for making progress on either. Internal multi-agent operation — decomposing work across several agents within one accountability boundary — is a distributed systems problem with a specific authority discipline attached. Inter-organisational operation, where the counterparty is outside your control entirely, is a commercial and legal problem wearing engineering clothes. The controls that work for the first are unavailable for the second, because they all depend on a shared policy engine that does not exist across a company boundary.

This paper treats each in turn. For the internal case the governing rule is that authority narrows on every delegation and never widens, and the characteristic failure is the confused deputy: a low-authority agent that can cause a high-authority agent to act has, in effect, been granted that authority. For the inter-organisational case the governing observation is that nothing enforceable crosses the boundary except the contract — so the contract has to carry weight it has never previously been asked to carry, including agent disclosure, authority limits, identity, the record of truth, reversal windows and a right to demand a human.

Running underneath both is a claim about accountability. It does not diffuse, dilute or disappear as systems become more distributed. Someone remains liable for every consequence. What actually happens is that the organisation loses track of who, and rediscovers it during an incident, at the worst possible moment and usually in a dispute. The remedy is an accountability map maintained as a deliverable rather than reconstructed as an investigation.

2. Two problems, not one

2.1 Inside the boundary

Internal multi-agent operation means several agents, possibly with different tools and models, cooperating on work for which one organisation is accountable throughout. There is a shared policy engine, a shared world model, a shared action log and, ultimately, a named person. Every control described in the second paper remains available.

The genuine hazards here are those of any distributed system, sharpened by the fact that the components are non-deterministic: authority leaking between components, feedback loops between agents that no single agent can see, and cumulative effects that exceed any individual agent's limits. These are tractable with discipline, and Section 3 sets out what that discipline is.

It is worth saying plainly that most decomposition into multiple agents is unnecessary. A single agent with a well-designed tool surface is simpler to reason about, simpler to validate and simpler to debug. There are three good reasons to decompose — separating capabilities that must not be combined, containing blast radius, and permitting independent lifecycles — and one bad one, which is the aesthetic appeal of specialisation. Decomposition adds coordination failure modes that do not otherwise exist, and it should be justified against those three purposes rather than adopted as a default architecture.

2.2 Across the boundary

Inter-organisational operation is categorically different, and the difference is not degree of trust. It is that the mechanisms of control simply are not present.

Mechanism

Inside the boundary

Across the boundary

Policy enforcement

One engine validates every plan

Each party enforces its own; neither can see the other's

World model

Shared state, resolved identity

Two models that disagree, with no arbiter

Authority

Delegated and verifiable

Asserted by the counterparty; verifiable only if agreed in advance

Compensation

System can undo its own effects

Requires the counterparty's cooperation

Halting

Stop the system

No ability to stop theirs; only to stop responding

Record of truth

One action log

Two logs that may diverge; neither is authoritative alone

Recourse

Management action

Contract, then commercial pressure, then law

 

Every row in the right-hand column resolves, ultimately, to an agreement between the parties. This is the paper's practical thesis: at the organisational boundary, the commercial instrument is the control, and the engineering exists to make the contractual terms enforceable and evidenced rather than to substitute for them.

3. Authority inside the boundary

3.1 Delegation narrows

The organising rule for internal multi-agent systems is monotonic: the authority held by any agent is a subset of the authority held by whatever delegated to it, and no mechanism exists by which it can be widened. An orchestrator authorised for A1 to A3 actions within stated limits may grant a sub-agent A1 to A2 within tighter limits; it may not grant A4, and it may not grant limits larger than its own.

Figure 1 — Authority as a narrowing delegation. The prohibited edge is the confused-deputy pattern.

This must be represented and enforced, not assumed. Each agent invocation carries an authority token describing the permitted tool set, tier ceiling, value and rate limits, and expiry. The policy engine evaluates every proposed action against the token accompanying the request. Where authority is implicit in configuration rather than carried explicitly, the narrowing property cannot be checked and will eventually be violated by a refactoring that nobody recognised as a security change.

3.2 The confused deputy

The characteristic multi-agent failure is subtle enough to survive review. Agent A is authorised to place orders. Agent B is a read-only extraction agent with no action tools, and is therefore assessed as harmless — it can be exposed to untrusted supplier documents without concern. But agent B can send a message to agent A, and agent A acts on it.

Agent B now has agent A's authority. The separation described in the second paper — extraction agents hold no action tools — has been undone by a communication channel that nobody classified as a capability. And because agent B reads untrusted content, an instruction embedded in a supplier document has just acquired the ability to place orders.

The rule that prevents this: a request carries the authority of its originator, not of its executor. When agent A receives a request that originated with agent B, it evaluates that request against agent B's authority token, not its own. Where the originator lacks the authority, the request is refused regardless of what the executor is permitted to do.

Communication is a capability

Any channel by which one agent can influence another's behaviour is an authority-bearing channel and must be enumerated, tiered and enforced exactly as a tool is. A shared scratchpad, a message queue, a common memory store and an ordinary function call are all the same thing from this perspective. Architectures described as "agents that collaborate freely" have, in authority terms, one agent holding the union of all their permissions.

 

3.3 Loops, amplification and global budgets

Two agents that can each trigger the other constitute a loop, and loops in systems with retry logic amplify. The mechanism is mundane: agent A requests, agent B fails and reports, agent A reinterprets and requests again, each iteration consuming budget and possibly producing external effects. Individually every step is reasonable.

The controls are structural rather than behavioural. Every run carries a global budget — total actions, total external contacts, total value, wall-clock duration — enforced by the policy engine across all agents in the run rather than per agent. Every message carries a hop count and a run identifier so that cycles are detectable. Depth of delegation is capped. And any run that exceeds its budget halts rather than degrading, because a system that quietly continues under pressure has removed the only signal that something was wrong.

3.4 One policy engine

The temptation in a decomposed architecture is to give each agent its own validation. This defeats the purpose. Cumulative blast radius is a property of the run, and a per-agent validator cannot see it: three agents each acting within a conservative individual limit can jointly commit an amount none of them was authorised to commit.

Planning is decentralised; enforcement is centralised. Every action, from every agent, passes the same policy engine holding the same run-level state. This is a modest engineering constraint and it is what makes the multi-agent case assurable at all.

4. The organisational boundary

Across the boundary the picture changes because the enforcing components exist on both sides and neither can see the other.

Figure 2 — What crosses and what does not. Messages cross; authority does not; compensation requires cooperation.

4.1 Three questions that get collapsed

When a message arrives from a counterparty's agent, three distinct questions must be answerable, and treating them as one is the source of most confusion in this area.

1.   Who is this? The authentication question: is this the entity it claims to be, established by credentials agreed in advance rather than by content.

2.   Who does it act for? The delegation question: on whose behalf, and can that principal's endorsement be verified independently of the agent's own assertion?

3.   What may it commit to? The authority question: does the principal accept that actions taken by this agent bind them, and within what limits?

The third is the one that matters commercially and the one least often settled. An agent asserting an authority limit is making a claim about its own permissions, which is worth exactly as much as any other self-report. The limit has to be established between the organisations, in advance, and referenced — not negotiated between the agents at the time.

4.2 The record of truth

Each party has its own log, and in a dispute each party's own log is worth very little, because both were written by systems under their author's control. What is needed is a record that neither party can unilaterally revise: exchanged messages with content hashes, timestamps and acknowledgements, retained by both parties under an agreed retention period, with an agreed procedure for reconciling divergence.

This need not be elaborate technology. Signed message digests exchanged and acknowledged at each step, retained on both sides, are sufficient for the overwhelming majority of commercial disputes and require no shared infrastructure. What is essential is that it is agreed before the first transaction rather than assembled after the first disagreement.

4.3 Compensation requires cooperation

The compensation discipline of the second paper assumed the system could undo its own effects. Across the boundary it cannot. Cancelling an order, releasing a booking or withdrawing a commitment requires the counterparty to accept the cancellation, and whether they will is a commercial matter.

This means the reversibility classification of paper one must be reassessed at the boundary. An action classified as compensable internally may be irreversible externally, because the compensating action depends on someone else's agreement. The conservative and correct default is that anything crossing the boundary is compensable only where a contractual reversal right exists, and irreversible otherwise.

5. Speed and correlation

5.1 The exposure window

Agent-to-agent interaction operates at machine speed. Human recourse operates at organisational speed. The gap between them is where damage concentrates, and it is a new phenomenon in commercial operations — the analogous problem in trading took a market structure crisis to make visible.

Figure 3 — Machine cycle against human recourse. A settlement window converts an irreversible exchange into a compensable one.

The consequence is that an entire commercial cycle can complete before any human on either side is aware it started. If the cycle was based on an error — a mis-extracted specification, a misread quantity, an injected instruction — the error has propagated into the counterparty's systems and possibly into their onward commitments before anyone can intervene.

5.2 Deliberate latency as a control

The remedy is to insert time on purpose. A settlement or cooling-off window — an agreed interval between an exchange being concluded and it taking effect, during which either party may withdraw without penalty — restores the possibility of human intervention without requiring a human in the transaction.

This is a contractual mechanism with an engineering counterpart, and it is the boundary-crossing version of the paper one principle of re-engineering an irreversible action into a compensable one. It costs latency that in most industrial procurement is entirely affordable: an award that takes effect four working hours after agreement rather than instantly changes nothing commercially and changes everything about recoverability.

Where the window is agreed, the engineering follows: the exchange is recorded as provisional, the counterparty is notified of the effective time, monitoring runs against the provisional state, and withdrawal is a defined operation on both sides rather than an apologetic phone call.

5.3 Correlated behaviour

A less obvious hazard arises from homogeneity. If many organisations in a supply chain deploy agents built on similar models with similar prompting, they will respond similarly to the same stimulus. A supply disruption, a price signal or an ambiguous specification can produce simultaneous, similar responses across many counterparties.

This is herding, and its effects are familiar from algorithmic trading: amplified volatility, sudden liquidity withdrawal, and the appearance of coordination where none was intended. In physical supply chains the equivalent is many buyers simultaneously accelerating orders on the same signal, producing a shortage that the signal only predicted.

No single organisation can fix this, but each can avoid contributing to it: rate-limit responses to market-wide signals, require human review for actions triggered by external events rather than internal need, and monitor for the case in which many counterparties behave identically at the same moment, which is itself the detectable signature.

6. Contracting for agent interaction

Since the contract is the only enforceable control at the boundary, it must be extended to carry matters that commercial agreements have not previously addressed. The following belong in any agreement under which agents will transact.

Term

What it establishes

Why it matters

Disclosure

Each party discloses whether an agent, rather than a person, may act on its behalf, and in which processes

A party has a legitimate interest in knowing whether it is negotiating with a system

Identity and authentication

Credentials, key exchange and how an agent is recognised

Otherwise identity is asserted by the counterparty and unverifiable

Authority limits

What each party's agent may bind it to, by value, volume and action class

Converts a self-reported limit into an agreed one

Record of truth

What is retained, by whom, for how long, and how divergence is reconciled

Determines what a dispute is decided on

Settlement window

Interval between agreement and effect; withdrawal rights within it

The mechanism that makes boundary-crossing actions compensable

Human escalation right

Either party may require a matter to move to named humans, and the other must honour it

The brake; without it there is no way to interrupt an exchange

Error and liability

Allocation of responsibility for agent error, and the remedy

Determines who bears the cost, decided in advance rather than in dispute

Change notification

Notice when a party materially changes its agent's behaviour or authority

The counterparty's risk assessment depends on assumptions that can silently expire

6.1 The escalation right is the important one

Of these, the right to demand a human is the term most worth insisting on and the one most likely to be omitted. It is the only mechanism by which either party can interrupt an automated exchange that is going wrong, and it must be unconditional — not subject to justification, not subject to the counterparty agreeing that escalation is warranted, and honoured within a stated time.

Its engineering counterpart is that both sides must be able to act on it. An organisation that cannot pause an in-flight exchange and route it to a named person has agreed to a term it cannot perform. This is worth testing rather than assuming.

6.2 On protocols

Interoperability standards for agent communication are developing quickly, and they are useful for what they address: discovery, invocation, message structure and, in some cases, authentication. It is worth being clear that the properties this paper has argued are load-bearing — verifiable delegated authority with limits, reversibility semantics attached to actions, idempotency across organisations, and an agreed record of truth — are largely not addressed by current interoperability work, and are the harder part.

The practical consequence is that these cannot be deferred to a standard. They should be settled bilaterally now, in the commercial agreement, in terms that a future protocol can implement rather than replace. An organisation that has agreed authority limits, a settlement window, an escalation right and a retention regime with its major counterparties has the substance; adopting a protocol later is then a matter of encoding it.

7. Accountability is conserved

It is common to hear that accountability becomes unclear in multi-agent systems. This is a description of an organisational failure, not of a property of the systems. Legally and commercially, someone is responsible for every consequence: the organisation whose agent acted, and within it the person who authorised the capability. Distribution across components changes nothing about that.

What genuinely happens is that the organisation stops knowing where accountability sits, and finds out during an incident. The remedy is unglamorous: write it down in advance and keep it current.

7.1 The accountability map

For every class of action the system can take, the map records who authorised the capability to exist, who set its limits, who monitors its operation, who is accountable for its consequences, and — where the action crosses the boundary — which agreement governs it and who owns the counterparty relationship.

Three properties make it useful rather than decorative. Every row names an individual role, not a team or a function, because a team cannot be accountable. Every row is reviewed when the system changes, which means the map is a configuration item under the change control of the second paper. And the map is reconcilable against the deployed system: if the system can take an action that appears in no row, either the map is stale or the action should not exist, and both are findings.

7.2 Delegation chains must be reconstructible

When something goes wrong, the question is what authorised this. In a decomposed system crossing a boundary, the answer is a chain: a named person authorised a capability; the orchestrator delegated a subset to a sub-agent; that agent, acting under a standing authorisation, instructed a counterparty's agent under a specified agreement.

Every link in that chain must be recoverable from the action log without inference. This is a concrete logging requirement rather than a governance aspiration: each action record carries the authority token it executed under, the identity of the requester, the run and plan identity, and where applicable the standing authorisation and agreement references. A record that shows what happened but not under whose authority is insufficient for the only investigation that will matter.

7.3 Where the map usually breaks

Three patterns account for most gaps. Capabilities added incrementally without a corresponding map update, so the system quietly outgrows its documented authority. Standing authorisations that were granted for a stated period and never expired, so the named authoriser has moved on and no one has replaced them. And boundary-crossing actions governed by an agreement that predates agent use entirely, where the contract references a manual process that no longer takes place.

All three are detectable by periodic reconciliation between the deployed capability set and the map, which should be scheduled rather than triggered.

8. A worked boundary crossing

Extending the procurement example of paper one: the organisation's sourcing agent now transacts with suppliers whose responses are generated by their own agents. The internal arrangement is unchanged; what follows concerns the boundary.

 

Concern

Internal treatment

Boundary treatment

Supplier identity

Approved vendor register

Register plus agreed credentials; unauthenticated responses accepted as information only, never as commitment

Response content

Extracted and normalised

Extraction agent holds no action tools; typed output only; values range-checked against the requirement and against other responses

Quotation validity

Checked against the record

Governed by the agreement; a validity period asserted only in the response is not relied on

Clarification exchange

Templated queries

Templated only, from an agreed set; free text requires a human on both sides

Award

A4, human commitment

A4 plus a settlement window before the award takes effect

Withdrawal

Compensating action

Contractual withdrawal right within the window; outside it, commercial negotiation

Dispute

Internal action log

Exchanged signed digests retained by both parties

Escalation

Route to reviewer

Either party may demand named humans; honoured within an agreed time

 

Two observations. First, the award remains gated exactly as it was — the boundary changes nothing about that, because the action was already irreversible. What the boundary adds is the settlement window, which is the only new mechanism and the one that does the most work.

Second, the clarification exchange is where the design earns its keep. A free-text conversation between two agents, each reading the other's output as instruction-bearing content and each able to influence a live commercial process, combines every hazard in this series. Constraining it to an agreed template set removes the hazard at the cost of some expressiveness, and where genuine free-text discussion is needed the answer is that it is a conversation between people.

9. Build sequence

Step 1 — Justify the decomposition

For each proposed agent, state which of the three legitimate purposes it serves: capability separation, blast-radius containment, or independent lifecycle. Agents serving none of these should be merged. Coordination failure modes are real and are not worth acquiring for tidiness.

Step 2 — Make authority explicit

Implement authority tokens before implementing inter-agent communication. Every invocation carries one; the policy engine evaluates against the originator's. Retrofitting this once agents are already talking is substantially harder, because the channels will already have been assumed harmless.

Step 3 — Enumerate the channels

List every way one agent can influence another, including shared state and indirect paths. Each is a capability with a tier. Anything not on the list should not be possible.

Step 4 — Centralise enforcement, budget globally

One policy engine, run-level budgets across all agents, hop counts and depth caps on messages, and a hard halt on budget breach.

Step 5 — Reclassify every boundary-crossing action

Reassess reversibility at the boundary. Anything whose compensation depends on the counterparty is irreversible unless a contractual reversal right exists. Expect this reclassification to move several actions up a tier, which is the correct outcome rather than a problem with the method.

Step 6 — Negotiate the terms before the integration

Disclosure, identity, authority limits, record of truth, settlement window, escalation right, liability and change notification. Start with the two or three counterparties that carry most of the volume; the terms agreed with them become the template.

Step 7 — Build the accountability map, then reconcile it

Populate it during design rather than after deployment, and schedule reconciliation against the deployed capability set. Treat any action without a row as a finding.

Step 8 — Test the escalation path

Exercise the human escalation right with a real counterparty, mid-exchange, and measure what happens. A contractual right that neither side has ever performed is unlikely to work first time under pressure.

10. Closing observations

The interesting boundary in agentic systems is not between the human and the machine. It is between organisations, and it is where every internal control stops applying. Inside the boundary the problem is engineering discipline: narrow the authority, enumerate the channels, centralise enforcement, budget globally. These are solvable and largely solved elsewhere.

Across the boundary the tools are commercial. Nothing enforceable crosses except what was agreed in advance, which means the agreement has to carry properties it has never previously been asked to carry — who may bind whom, to what, evidenced how, reversible within what window, interruptible by whom. Organisations that treat this as a future standards problem will find that the standards, when they arrive, encode terms rather than supply them.

The claim worth carrying forward is the one about accountability. It is not diluted by distribution and it is not absorbed by the technology. Every action an agent takes is an action some organisation took, and within that organisation some person authorised the capability, set the limits, or failed to withdraw an authorisation that should have expired. The difference between a well-run programme and a poorly-run one is not whether that is true. It is whether the organisation knows it before the incident or discovers it afterwards.

Write the map. Negotiate the terms. Then build the agents.

About this paper

This is the third paper in "Systems That Act", following "The Commitment Point" and "The Tool Surface". The final paper addresses assurance and operations for systems that change state. Contractual matters are discussed as design considerations and do not constitute legal advice; terms should be settled with qualified counsel. Examples are illustrative and generic. The paper is vendor-neutral: capabilities are described functionally and no specific platform, model, agent framework or interoperability protocol is recommended.