For years, arguments about standards for autonomous systems have concentrated on transport and syntax. Can one agent call another. Can one workflow trigger a tool in a different organisation. Can a model hand off a task to a service in another jurisdiction using a common message format. Those questions matter, but they are no longer the binding constraint. The deeper obstacle is whether a receiving system can inspect, verify and rely upon the assurance claims attached to an action, recommendation or decision. In mid-2026, the frontier in standards is not simply machine-to-machine communication. It is machine-readable accountability.
This is a distinct problem from the familiar interoperability agenda. Traditional interoperability asks whether systems can exchange data faithfully. Autonomous coordination asks whether they can exchange reasons for trust: provenance of inputs, identity of the acting entity, model and policy constraints, applicable legal context, evidence of testing, retention obligations, and the conditions under which a result may be reused or escalated to a human. Once software begins to negotiate, recommend, triage, purchase, schedule or report on behalf of institutions, those assurances stop being compliance paperwork in a drawer. They become operational requirements.
Why shared APIs are no longer enough
Conventional API standardisation solved a world in which software executed narrow, predictable functions. The calling service could assume both the semantics of the response and the liability posture around it. Autonomous systems disturb that settlement. A response is no longer merely a value returned by a stable service; it may be the output of a probabilistic model, a derived judgement assembled from multiple tools, or a delegated action carried out under internal policies invisible to the requester.
That creates a verification gap. A hospital workflow engine, customs platform, research repository or municipal service may successfully receive a message and still have no basis for deciding whether to act on it. Was the result generated from approved data. Was a human required to review the case. Does the sending system have authority to make the claim. Has the underlying software build been attested. Which jurisdiction’s retention and explanation duties apply. Interoperability without answers to such questions is merely automated ambiguity.
Interoperability without shared assurance is merely automated ambiguity.
The shift from identity to attestable conduct
Digital trust frameworks have long focused on who or what is connecting. Electronic identification, signatures and organisational credentials remain essential, and Europe’s eIDAS architecture shows how far cross-border trust services can be institutionalised. But for autonomous systems, identity is only the first layer. A verified identity does not say whether an action was produced under an approved model version, whether a system respected use constraints, or whether the output carries known uncertainty requiring human review.
What is emerging instead is a broader stack of attestable conduct. The most relevant standards work is borrowing from several older domains at once: software supply-chain security, digital credentials, records management, safety engineering, and administrative law. The result is a move towards artefacts that travel with an output or action: signed provenance records, policy declarations, credential chains, evaluation summaries, and cryptographically verifiable logs. These do not create trust automatically, but they make trust inspectable.
Assurance as a protocol problem
To understand why this matters, it helps to frame assurance itself as a protocol problem. A protocol is not just a wire format. It is an agreed method for making state legible across boundaries. In payments, that means settlement instructions and reversibility rules. In the web, it means methods for requesting and serving content. In autonomous systems, it increasingly means standard methods for expressing claims such as: this output came from these sources; this tool execution happened in this environment; this model was evaluated against this task; this decision falls inside these policy limits; this record may be stored for this long; this case must be escalated if confidence falls below this threshold.
Interoperability without shared assurance is merely automated ambiguity.
None of these claims can remain free-text notes if cross-organisational automation is to scale. They must become structured, signed and selectively disclosable. A receiving system will need to parse not only a result, but the package of evidence around it. In practice, that points towards combining credential models, software attestation, identity frameworks and risk controls into interoperable assurance envelopes. The standards race is shifting from message exchange to machine-readable accountability.
Lessons from software supply chains
The most mature analogue may come from secure software development rather than AI governance. NIST guidance and industry frameworks around software provenance treat code artefacts as objects that should carry evidence of how they were built, by whom, and under what controls. That logic is spreading. If an autonomous system is assembled from models, retrieval components, external tools and policy filters, each part may need provenance metadata and attestation. The question is no longer only whether a system passed a test at launch. It is whether each consequential output can be related back to governed components and authorised execution paths.
This matters especially where systems dynamically compose capabilities. An agent may invoke a mapping service, a retrieval layer, a classifier and an external registry in one chain of action. Without standard evidence about those calls, post hoc audit becomes a forensic exercise. With it, audit can become a normal property of operation. The goal is not perfect observability. It is enough structured evidence to support contestability, incident response and supervisory review.
Europe’s quiet influence
Europe’s role in this shift is less about inventing a universal technical stack than about changing what interoperability must include. The AI Act, the wider digital identity agenda, data governance efforts and the European Interoperability Framework all point in a similar direction: cross-border digital systems must be able to show how authority, compliance and accountability travel with transactions. The practical implication is significant. A system acting across Member States may need to carry claims not just about authentication, but about legal basis, human oversight arrangements, record-keeping and redress pathways.
That does not mean regulation will dictate protocol design line by line. More often, it sets the assurance obligations that protocols must eventually encode. Technical communities then translate those obligations into schemas, trust registries, conformance profiles and verification methods. This is a familiar pattern from privacy notices, electronic signatures and product conformity regimes. Law defines the accountability surface; standards determine whether that surface can be machine-handled.
Why credentials are gaining ground
One reason verifiable credentials have attracted renewed attention is that they offer a model for portable claims with cryptographic integrity. A credential can state that an entity holds a role, meets a requirement or has passed a particular check, and a verifier can inspect the issuer, signature and revocation status. On their own, credentials are not a governance solution. Yet they are increasingly useful as carriers for narrow, reusable assurance statements: an operator’s authority, a model card summary, a conformity declaration, a dataset licence condition, or a statement that a component was built under a documented process.
The attraction is not ideological decentralisation. It is operational modularity. Large institutions do not want every system integration to require bespoke bilateral trust engineering. They want reusable ways to check whether a claim about identity, authority or process can be verified automatically and logged for audit. A system that can act across borders must also carry its own evidence.
A system that can act across borders must also carry its own evidence.
A system that can act across borders must also carry its own evidence.
The hard part is semantics, not signatures
Cryptography can secure a claim, but it cannot by itself make that claim meaningful. The difficult problem is semantic alignment: what exactly does it mean for a model to be approved, a risk assessment to be current, a human review to be completed, or a data source to be authoritative. These are domain-specific judgements. A health system, a port authority and a labour inspectorate will not define them in the same way.
This is why the standards landscape is likely to remain layered rather than universal. Horizontal protocols may define envelopes, signatures, status checks and logging methods. Sectoral profiles will define the specific assurance vocabulary for health, mobility, trade, finance or public administration. The long-run challenge is to ensure that these sectoral languages remain composable enough for cross-domain workflows. Otherwise, the world may end up with highly trustworthy silos rather than genuine coordination.
Auditability as runtime infrastructure
There is a temptation to think of auditability as an after-the-fact function for regulators and internal compliance teams. Autonomous coordination makes that view obsolete. Auditability is becoming part of runtime infrastructure. A receiving system may refuse to execute a delegated action if the necessary attestations are missing. A procurement workflow may require evidence that outputs derive from approved models and datasets. A public-sector case system may need to preserve the exact policy state under which a recommendation was generated. In such settings, assurance data is not archival decoration. It determines whether the workflow continues.
This changes the economics of standards. Protocols that reduce assurance-checking costs will have strategic value even if they add overhead to simple message passing. Institutions would rather accept slightly slower automation than create unmanageable exposure by allowing opaque actions to propagate across networks. As NIST, OECD and WHO guidance in different contexts all suggest, trustworthy AI is inseparable from documentation, traceability and human governance. The novelty is that these attributes are moving from governance manuals into executable exchange rules.
What failure will look like
The most likely failure mode is not a dramatic breakdown of communications. It is the opposite: seemingly smooth interoperation that masks unresolved accountability. Systems will exchange outputs happily until a dispute arises over a denied benefit, a flawed medical triage, a misrouted shipment, a procurement error or an unlawful data use. At that point institutions will discover that they can identify the sender but not the basis of the action, verify the message but not the authority behind it, or retrieve a log but not reconstruct the policy and model context in force at the time.
That kind of failure is politically corrosive because it exposes a mismatch between automated capacity and institutional legibility. Citizens and counterparties do not care that two systems exchanged standards-compliant JSON if no one can explain why a consequential action occurred. The point of protocol design in this domain is therefore constitutional as much as technical: it distributes power to act, to verify, to challenge and to halt.
The new geography of trust
Another consequence is geopolitical. Countries and blocs are not merely competing to host the best models or the largest compute estates. They are shaping the trust conditions under which autonomous systems can be admitted into sensitive workflows. Assurance standards may become a subtle instrument of market access and administrative sovereignty. If a jurisdiction requires specific forms of provenance, logging or credential-backed authority, foreign systems will have to conform or remain at the edge of the workflow.
The standards race is shifting from message exchange to machine-readable accountability.
This need not produce digital protectionism. Properly designed, common assurance protocols can lower barriers by making compliance evidence portable. But they will also reward jurisdictions that can align legal duties with technical verification methods. The advantage will go not simply to those that standardise first, but to those that standardise in ways that public administrations, regulated industries and auditors can actually operate.
What mature coordination may require
By the end of this decade, mature autonomous coordination across borders is likely to depend on a bundle of capabilities rather than a single standard. At minimum, systems will need interoperable identity and authority credentials, signed provenance records for key actions, common methods for declaring policy constraints and human-oversight requirements, reliable event logging, and mechanisms for revocation or suspension when components fail, drift or lose authorisation. They will also need governance interfaces: not just APIs for machines, but inspection points for supervisors, auditors and affected institutions.
- Portable credentials to prove who may act and in what capacity.
- Attestations linking outputs to approved software, models and data sources.
- Structured policy metadata describing limits, retention and escalation rules.
- Verifiable logs that preserve sequence, context and integrity of actions.
- Status and revocation services so stale trust can be withdrawn quickly.
None of this guarantees safe or fair outcomes. Standards rarely solve substantive political disagreement. What they can do is prevent disagreement from disappearing into opaque automation. That is a more modest but more realistic ambition.
From connectivity to governability
The common metaphor for digital progress has long been frictionless connection. For autonomous systems, the more useful concept may be governable connection. Systems must be able not only to reach one another, but to carry enough structured evidence that institutions can authorise, constrain, inspect and contest what happens next. In that sense, the missing layer in autonomous coordination is neither intelligence nor bandwidth. It is governability encoded in protocol form.
Open standards will still matter, perhaps more than ever. But the decisive standards may turn out not to be those that make autonomous systems talk. They will be those that make autonomous actions legible to organisations that did not design the system, regulators that did not deploy it, and counterparties that do not already trust it. That is a different and more exacting test of interoperability than the industry first imagined.
