OOOMETA/OS
← Back to Insights

November 2026 · 5 min read

A2A connects agents; it does not assign work

A2A connects agents; it does not assign work

Key Definitions

Task ownership Who may issue, claim and accept a piece of work. It is organisational semantics and sits outside the scope of a communication protocol.

Idempotent completion A completion action that does not change the result when repeated. A second call returns already closed instead of overwriting the first conclusion.

Claim exclusion One task card can be taken by one executor at a time, enforced by an atomic status update rather than by convention.

One morning in September two scheduled jobs woke in the same minute and read the same pending list. Forty minutes later two report files sat in two directories, each headed with a claim that it was the only implementation and that the other copy had been deleted.

Both files were correct. Read alone, each one ran, cited scripts that existed, and matched the situation on the ground. The content was not the problem. Nobody owned the question of who does this card, how many times, and who accepts it as finished. Each report believed it was the authorised copy.

We did not respond by editing a prompt or adding a rule that said do not duplicate. That rule gets forgotten in the first week and routed around in the second. We changed the queue: re-read the pending list before claiming, and require a unique key at completion. That is not a moral requirement. It is a data structure.

The protocols have already standardised reach

This layer moved faster this year than anyone expected. MCP defines itself as an open standard for connecting AI applications to external systems, using the USB-C port for AI applications as its own analogy, with the current specification at version 2026-07-28. MCP documentation

A2A takes the other half: connecting agents to other agents. Its official site lists the v1.0 specification, six official SDKs, more than 170 community partners, an Apache 2.0 licence and neutral governance at the Linux Foundation. In October 2026 it shipped an A2A CLI so a local coding assistant can discover and delegate to other agents. a2a-protocol.org

Read the five capabilities that page lists: interoperability, complex workflows, secure and opaque, works with MCP, extensible. All five are about whether agents can connect, whether the connection is safe, and whether it can grow. Not one is about who may issue a task, who may claim it, and who declares it finished.

That absence is not an oversight in the spec. A task is an object in an organisation, and the right to issue one is the right to sign, which is company structure. To standardise it, the protocol layer would first have to decide for every company who is allowed to sign, and that agreement does not exist at industry level. So the protocols wisely do transport only and leave ownership to the application. Most teams install the protocols and never build that other half.

Once the channel is standard, ownership breaks first

The protocol standardises how messages travel. It assumes both ends already hold a defined task. That assumption holds when one person can see the whole batch. It fails when an organisation has dozens or hundreds of executors waking on their own schedules.

Our own fleet shows the scale: 108 scheduled jobs on one profile, each waking on its own cron expression, some every two hours, some daily, some waiting for an external signal. The task store holds 3,347 tickets and 38 are open right now. Any two jobs that wake inside the same five minute window and read the same list can each write a version.

This failure is hard to catch in logs, because both artifacts look clean. What settles it is disk fact. Both file headers claim the other copy was deleted, and that claim is worthless as evidence, because both sides write it. What can be checked is whether every cited script path exists and whether the write timestamp is earlier than the current clock. Those two checks are how we found the duplicate. A cited tool must exist, and a timestamp must not sit in the future.

So duplication is not a model problem and not a framework problem. It is missing semantics. The protocol gives you permission to call. It does not give you only one caller may act.

Four queue semantics we actually run

First, a task is a record, not a sentence in a chat. The record carries four fields: a unique id, one owner, an entry time, and an acceptance criterion. Missing any one of them makes it a request rather than a task. This looks bureaucratic, and its purpose is to give the question who is on this a queryable answer instead of a log search for everyone.

Second, claiming must be exclusive. Re-read the pending list immediately before claiming, because it changes between your read and your write. The status update is atomic, so when two executors claim one card only one succeeds. There is also a cheap detector: if a card was updated less than five minutes ago, treat it as handled by someone else, read their conclusion, and do not write your own.

Third, completion must be idempotent. The completion call carries a unique key, and a second completion returns already closed instead of overwriting the first. We learned this from a real race. The completion call answered that the card was already done, we spent half a day hunting a bug, and then accepted that the answer was the race firing correctly rather than an error.

Fourth, the proof must be something that exists. The closing note carries one absolute path to one artifact on disk. Not a sentence of explanation as well, because explanation lets people believe the work is finished while a path cannot lie: absent is absent.

None of these four appear in the MCP or A2A documentation, because none belong in the transport layer. That also explains why changing frameworks leaves the problem in place. LangGraph gives you a graph and state, CrewAI gives you roles and collaboration, and the task lifecycle still sits in your storage while cross process exclusion still has to happen in your database. The framework decides how work flows. The queue decides that one piece of work flows once.

Better interoperability makes ownership more expensive

What A2A really changes is not capability but call volume. A pipeline that ran ten times a day now has downstream agents calling it dozens or hundreds of times. Duplicate execution does not rise linearly. It tracks how many executors are alive at once, and going from two executors to ten takes the chance of a collision close to forty-five times higher.

That yields an uncomfortable conclusion. Protocols lower integration cost and can raise coordination cost. Once integration gets cheap, the business side attaches more work to the same chain, volume climbs, and if coordination still means someone asking in a chat who is on this, it becomes the bottleneck before any model capability does.

The pain therefore lands harder on enterprises than on small teams. In a small team one person watches everything and a human brain is the lock, so nothing collides. At the scale of departments, time zones and vendors, the lock has to move from a brain into a system, and that step gets skipped because no protocol document mentions it.

Four buyers, four decisions to make

For the C-suite: orchestration budget should be argued on two numbers, the share of tasks that pass on the first attempt and the share that execute twice. Both can be counted from records. Budgeting per agent is budgeting output per head, and at scale you get more executors and the same number of duplicates.

For the transformation lead: settle an ownership matrix before discussing interoperability, naming which classes of work only which unit may start. That matrix is not process paperwork. It is the issuing rule for the queue. Without it, every unit will start the same piece of work after interconnection, because from each unit s angle that work belongs to it.

For the AI application lead: queue semantics come before framework selection. Frameworks turn over every two or three years and queue semantics do not. Write the four rules into your storage layer and they survive every migration. Pick the framework first and patch the semantics later, and you rebuild them each time.

For the compliance lead: the ownership record is the carrier of accountability. An auditor never asks whether the system ran. They ask who started the action, who approved it, and who accepted it. None of those three exist in a protocol. They exist in your task records.

Our judgement

First, this year the orchestration competition is not in protocols, it is in queues. This is falsifiable: if the protocol were the constraint, duplication and concurrent conflict should fall once interconnection lands. We observe the opposite. Once the channel opened, conflict rose, because more executors could call each other. If a vendor ships task issuing rights and idempotent completion inside the product in the next two quarters, that would be real progress.

Second, task ownership cannot be standardised, only localised. It encodes the right to sign, and the right to sign is company structure, which differs everywhere. No open protocol will unify this layer. Each company implements it in its own storage, or a product that admits the difference makes it configurable.

Third, MCP and A2A answer can, not should. They are different questions. Mixing them produces the conclusion that we should wait for protocols to mature, and when they mature the should question is exactly where it was.

When you do not need this

Not with one process and one executor. A single agent does not compete with itself for a card, and exclusion is code with no purpose.

Not when one person watches every executor. A human brain is the lock, and nothing collides. That scale is bought with attention and gets linearly more expensive as task volume grows, so it is a temporary state rather than an architecture.

Loosen it when work is idempotent and carries no external side effect, such as recomputing a report. Keep the unique key anyway, because duplicate output pollutes downstream judgement even when downstream can rerun.

Three steps for today

First, move tasks out of chat and lists into records with four fields: id, owner, entry time, acceptance criterion. This needs no architecture change and can be done today.

Second, add a unique key and a proof to completion. Submit one artifact path that exists, and reject a second completion instead of overwriting.

Third, re-read the pending list before every claim. It is the cheapest step with the most direct return, and almost every duplicate happens in that one second.

One question for the buyer: now that your agents call each other, who can answer which piece of work is running, how far it got, and who accepted it as done? If the answer is check the logs, ownership has not entered the system. The logs are only hiding that.

Sources: A2A Protocol official site, v1.0 specification and capability list a2a-protocol.org; Model Context Protocol documentation, specification 2026-07-28 modelcontextprotocol.io. Queue scale and the duplicate output case come from OOMeta operating records.

FAQ

A2A has v1.0 and over 170 partners, so what is missing+

Its five listed capabilities cover interoperability, complex workflows, secure opacity, MCP compatibility and extensibility. All concern whether agents can connect, none concern who may issue, claim or accept a task.

How does duplicate output happen+

Two executors read the same pending list in the same minute and each write a version. Both can be correct; the failure is that nobody owns the card.

How do you decide which copy is real+

Disk facts, never self description. Every cited script path must exist and no write timestamp may be later than the clock. Both headers claim the other copy was deleted, so that claim proves nothing.

Does switching orchestration framework fix it+

No. The framework supplies flow and state. Task lifecycle lives in your storage and cross process exclusion in your database, so a migration just rebuilds it.

Do protocols make this better or worse+

Worse in the short run. Interconnection lowers integration cost, call volume rises, more executors are alive at once, and the coordination cost climbs first.

Does a small team need this+

Not one process with one executor, and not when one person watches everything. That second case is bought with attention and gets linearly more expensive with volume.

Run the same check on your own execution log

Send a redacted 30-day agent execution log and get an eight-row table in 48 hours: one row per technical item, each cell carrying its numerator, denominator and criterion, gaps sorted by whether a schema change is needed. First three engagements are ¥8,000.

See the field check →