Diop Daily #145 — October 2026

A Protocol Speaks Before the Agent Does

When two agents meet, they do not exchange thoughts. They exchange messages shaped by a standard: how identity is presented, which authority is cited, what tool descriptions are discoverable, how refusal is expressed, and whether the interaction leaves evidence an institution can audit. The standard is not a neutral pipe. It is a governance contract written before any content passes through it. By the time an agent begins a sentence, the protocol has already decided what it is permitted to say, to whom, under what identity, in which language, and with what proof of boundary.

This is the layer that has begun to crystallize in the last month. Meta and Sierra announced a Personal Agent Protocol on October 6, framed as an open specification for secure AI-to-business interaction, with partners including Genesys, Instinct, Rocket, Shopify, Stripe, and Walmart. The W3C's Agent Protocol Community Group continues to define open, interoperable protocols for agent discovery, identification, and interaction. The IETF approved the charter for its agentproto working group on October 8, covering agent-to-agent, user-to-agent, and agent-to-tool interactions with an explicit delegation and authorization scope. Google continues to advance A2A through its ADK runtime, with multi-language SDKs now at version 1.0 for Java and Go. Each signal points to the same conclusion: the protocol layer is becoming the primary sovereignty surface for agent systems.

A standard is not a pipe. It is a contract that assigns identity, limits authority, selects languages, records refusal, and defines what must survive a provider change.

The protocol is the first sovereignty surface

Most institutions think of sovereignty in terms of data location: which country holds the server, which cloud region serves the model, which database retains the record. That view is incomplete for agentic systems. Before a model evaluates a request, the protocol must decide whether an agent is authorized to request it, whether the identity presented is valid, whether the delegation is current, and whether the requested tool belongs to a permitted category. Before a system of record changes, the protocol must specify which jurisdiction governs the effect, which language is authoritative for refusal, and which evidence must be preserved for recourse. These are not endpoint settings. They are protocol contracts.

The significance of the October 6 Meta and Sierra announcement is not the product category. It is the framing: a protocol designed to give AI agents a secure, consistent way to interact with businesses, with identity, authorization, and interaction structure built into the standard rather than added afterward. The significance of the October 8 IETF agentproto charter is not its list of working documents — it has none yet — but its scope: user-to-agent, agent-to-agent, and agent-to-tool interactions, with authorization and delegation treated as first-class protocol concerns rather than application-level patches. The significance of Google's A2A work through ADK is that multi-agent collaboration now has a common contract across Python, Java, and Go, making portability a protocol property rather than a framework accident.

What a serious agent protocol must carry

A protocol that treats identity, authorization, and jurisdiction as secondary concerns produces systems that appear interoperable while remaining ungovernable. A serious standard should specify the contract before the content. That contract should include at least the following fields:

  • Identity contract: how the agent proves it is the agent it claims to be, which authority delegated that proof, and whether the identity survives a provider or framework change.
  • Authorization boundary: which actions are permitted for this identity in this jurisdiction, in this language, at this time, and under which delegation condition.
  • Discovery contract: how tools, other agents, or institutional records are described so that a foreign runtime can understand what is offered without importing a proprietary schema.
  • Refusal contract: how denial is expressed, in which language, with which reason, and whether the refusal produces evidence the institution can examine.
  • Delegation record: which principal granted the agent its authority, with what expiry, under which jurisdiction, and with what revocation path.
  • Jurisdiction marker: which geographic or institutional authority governs the interaction, including the language of authoritative policy, and whether a cross-boundary redirect requires explicit approval.
  • Evidence contract: what trace, attestation, or receipt is preserved for each interaction, and how an institution can inspect it independently of the original provider.

None of these fields is decorative. Each is a point where a sovereign institution either retains control or loses it silently. A protocol that records identity but not delegation produces systems that cannot answer who approved an action when authority is contested. A protocol that records authorization but not jurisdiction produces interactions that may shift legal ground without the institution's awareness. A protocol that records refusal but not language produces denials that are technically present but operationally meaningless for a Wolof, Amharic, Arabic, or French-speaking reviewer.

The question is not whether agents will talk. The question is whose contract governs the conversation, and whether the institution can read it in its own language.

Why African institutions should care about the contract

The global agent ecosystem is moving quickly, but its direction is not predetermined. A protocol designed primarily around English-language business interfaces, centralized identity authorities, and uniform jurisdiction assumptions will become the default not because it is universal, but because it is first. African institutions that treat protocol adoption as a consumption decision — using what is available — will inherit governance choices made for other contexts. Institutions that treat protocol design as a sovereignty project — specifying which identity contracts, authorization languages, delegation records, and jurisdiction markers must be preserved — can shape the layer that governs agent interaction rather than merely applying it.

This is not abstract. A university that maintains a research agent for multilingual corpus retrieval must know whether the protocol used by that agent permits retrieval under community conditions distinct from the terms of an external provider. A public agency that operates an agent across local-language services must know whether the identity contract binds the agent to a national administrative authority, whether refusal is recorded in the authoritative language, and whether the delegation can be withdrawn when conditions change. A cooperative that connects members across borders must know whether the interaction contract keeps member records under a local custodian, whether cross-boundary redirects require explicit approval, and whether evidence survives a change of provider.

The protocol layer is where these obligations become enforceable. Without a contract that carries jurisdiction, language, identity, authorization, and evidence, the best governance framework is a recommendation applied to an opaque interaction. With such a contract, an institution can verify compliance independently, compare providers by governance rather than price alone, and recover from a provider failure without losing the record of what was permitted and what was refused.

The standard is not neutral

Every standard encodes a theory of interaction. A protocol that assumes a single centralized identity authority assumes that identity is owned by the provider. A protocol that allows delegation to be expressed in a portable contract allows identity to travel with the institution. A protocol that treats refusal as an error code rather than a governed outcome removes the institution's ability to prove that a boundary was respected. A protocol that does not specify language for authoritative policy assumes that English is sufficient for every institutional purpose.

The recent announcements make these choices visible. The Meta and Sierra protocol is positioned as open, yet its partners reveal its initial commercial orientation. The W3C group is genuinely open, yet its progress depends on which institutions contribute concrete requirements from non-English, non-centralized contexts. The IETF charter covers the right scope, yet its first working documents will determine whether jurisdiction, language, and delegation are primary protocol fields or optional extensions. Google's A2A work is technical and open, yet its runtime is embedded in a broader cloud architecture that carries its own jurisdiction assumptions.

None of this is a criticism of any single announcement. It is a statement of what the protocol layer now demands from serious institutions: active design participation, not passive consumption. A laboratory that treats agent communication as a standard it uses will inherit a sovereignty model built elsewhere. A laboratory that treats it as a standard it helps specify can embed the contracts — identity, authorization, jurisdiction, language, refusal, evidence — that make agent systems governable rather than merely connected.

Where the investable surface is widening

The commercial object is not the protocol document itself. It is the sovereignty layer that a serious protocol contract enables: a system of identity, authorization, delegation, jurisdiction, language, and evidence that allows institutions to operate agentic interactions with measurable governance rather than assumed compliance.

  • Sovereign identity infrastructure: open identity contracts for agent systems that bind identity to institutional authority, include expiration and revocation, and survive provider or framework change.
  • Multilingual authorization contracts: policy descriptions, refusal statements, and evidence records authored in the institution's authoritative language, not translated afterward as a courtesy.
  • Jurisdiction-bound delegation: delegation records that specify which jurisdiction governs an interaction, when a cross-boundary redirect requires approval, and how authority is withdrawn.
  • Portable discovery contracts: open descriptions of tools, agents, and institutional records that allow foreign runtimes to understand capabilities without importing proprietary schemas or hidden jurisdiction assumptions.
  • Evidence systems for agent interaction: independent audit trails that preserve identity, authorization, jurisdiction, language, refusal, and effect in forms readable without access to the original provider.
  • Local-language compliance environments: evaluation frameworks that test whether protocol-level contracts retain operational meaning across the languages and legal contexts in which the institution works.

The durable asset is the contract library: the set of tested, versioned, institution-specific protocol contracts that describe how identity, authorization, jurisdiction, and evidence must be handled. That library can serve multiple providers, multiple models, and multiple frameworks, because it describes the institution's obligations rather than any particular vendor's interface. When a provider changes, the contract travels. When a model updates, the authorization boundary remains. When a jurisdiction shifts, the evidence record preserves the transition.

Dessiner le contrat avant d'autoriser la conversation

An institution can begin with a concrete interaction: an agent that reads a restricted record, submits a translated document, approves a transaction, or delegates a task to another agent across organizational boundaries. Before the agent speaks, the protocol contract must specify identity, delegation, jurisdiction, language, authorization, refusal, and evidence. Only after the contract is written should the interaction be permitted. The contract is not paperwork added to automation. It is the architecture that makes automation governable.

  1. Write the identity and delegation contract: which authority grants the agent its identity, for how long, in which jurisdiction, and with what revocation path.
  2. Write the authorization boundary: which actions are permitted for this identity in this context, which languages govern refusal and approval, and which cross-boundary redirects require explicit authorization.
  3. Write the discovery and interaction contract: how the agent finds the required tool or peer agent, what the request must contain, and how refusal is expressed in the authoritative language.
  4. Write the evidence contract: what must be preserved for each interaction, in which form, and how an independent reviewer can inspect it without access to the original provider.
  5. Test the contract by removing the preferred provider, changing the language of instruction, revoking authority mid-task, and requiring cross-boundary approval — then verify that evidence survives each change.

The goal is not to make every interaction local or to prevent agents from communicating across organizations. It is to make every interaction verifiable under an institutional contract that the institution can read, enforce, and revise. A protocol that carries that contract becomes infrastructure. A protocol that hides it becomes dependency disguised as connection.

Sources