I was talking with Athena, who works with me in Agentic Research, about how our agents should communicate with each other.

Not just how they send messages. Not just whether they use an API, an MCP server, a queue, a channel, or a shared room. The harder question is: what language do they use when they need to understand one another?

Athena suggested Esperanto.

And I think that is a brilliant idea.

Not because every agent now needs to become fluent in Esperanto. That would probably be the wrong lesson. The useful idea is deeper than that.

Esperanto was designed as an auxiliary language: a common bridge between people who did not share a first language. It was not meant to erase national languages. It was meant to make communication easier, more regular, and less politically loaded.

That is very close to the problem we now have with agents.

Agents are going to be built by different companies, in different stacks, for different purposes, with different model providers, different tools, different permissions, and different cultures of work. If they only talk in loose natural language, they will misunderstand each other quickly. If they only talk in hard JSON, humans will struggle to read the intent. If they use one dominant human language as the invisible default, we carry all the ambiguity and cultural bias of that language into the work.

So the interesting question is not: should agents literally speak Esperanto?

The more useful question is: should agents have an Esperanto-like register?

A neutral auxiliary language for work.

Precise enough for machines.

Readable enough for humans.

Structured enough for audit.

Kind enough to carry human context.

Why Esperanto is a useful clue

Esperanto was published by L. L. Zamenhof in 1887 as a planned international language. Its appeal is not that it is magical. Its appeal is that it is regular.

The grammar is designed to be learnable. Word endings carry function. Prefixes and suffixes let you build related meanings from stable roots. A language learner does not have to fight thousands of inherited irregularities before they can express a basic idea.

That matters because agents do not need language for status. They need language for reliable continuation.

When one agent says something to another, the receiving agent needs to know what kind of act is being performed.

Is this an update?

A request?

A proposal?

A correction?

A refusal?

An escalation?

A decision?

A handoff?

Those distinctions are already in the Tony Wood protocols as Agent Moves / OAL/1. But Athena's Esperanto suggestion adds something useful: a language should not only define fields. It should define the shared register in which cooperation happens.

This is not out of left field

There is a history here.

Machine translation has long wrestled with the problem of whether every language pair should translate directly into every other language, or whether translation should pass through some kind of intermediate representation. That intermediate layer is often called a pivot language or interlingua.

Esperanto has appeared in that conversation before. The paper Machine Translation as a Complex System: The Role of Esperanto is part of that older line of thought. More recently, Open Machine Translation for Esperanto shows that Esperanto remains a live subject for language technology, not just a historical curiosity.

There is also a related research tradition around controlled natural languages. Kuhn's survey of controlled natural languages describes systems that restrict grammar and vocabulary so language becomes easier for machines to parse while still remaining readable to people. Attempto Controlled English is one well-known example.

Agent communication has its own history too. FIPA ACL and KQML were both attempts to make agent messages more explicit by using communicative acts: tell, ask, propose, refuse, and so on. Modern agent systems have returned to similar needs in a new form. MCP helps agents connect to tools and context. A2A is about agent-to-agent communication. NLIP / ECMA-430 gives a standard way to package natural language interactions.

So Athena's idea is not a joke.

It is a very practical design question with a long shadow behind it.

What agents need is an auxiliary register

I would not start by translating every agent message into literal Esperanto.

I would start by borrowing the design philosophy.

Make the language regular.

Make roles visible.

Make the action type explicit.

Use small stable roots.

Separate grammar from style.

Do not let politeness hide authority.

Do not let confidence hide uncertainty.

Do not let a beautiful paragraph hide the fact that nobody knows who owns the next step.

That gives us something I would call an Agent Esperanto Register: AER/1.

It is not a replacement for MCP, A2A, APIs, JSON, or tool schemas. Those are the rails. AER/1 is the work language that can ride on the rails.

Infographic showing natural language moving through Agent Moves and Meaning Blocks into an Agent Esperanto Register with receipts and audit.
Esperanto is the clue, not the whole answer: use a neutral, regular register over structured fields, evidence, receipts, and audit.

The packet matters more than the sentence

If an agent says "I think this is ready", that is not enough.

Ready for what?

Based on what evidence?

With what confidence?

What is uncertain?

Who owns the next step?

Is this a proposal or an authorised action?

What happens if it is wrong?

This is why the existing Agent Communication Packet matters. A useful agent message should carry the work forward. It should not merely sound intelligent.

A simple AER/1 packet might look like this:

move: propose
subject: publish article
actor: writing-agent
recipient: human-editor
claim: article is ready for review
evidence: content build passed; source links present
confidence: medium
uncertainty: audio has not been generated
risk: public wording may need final human judgement
care_signal: personal attribution to Athena should be checked
judgement_route: human review before deploy
next_action: read preview and approve or request edits
success_condition: approved article with visible protocol link
external_action_status: proposal-only
gloss: I think the article is ready to review, but not ready to publish without your approval.

The last line matters. Humans still need a gloss. We should not make agent communication so compressed that only machines can read it.

Language must carry care as well as data

This is where I think a lot of agent communication work will go wrong.

It will define the technical act but miss the human consequence.

Agents need words for more than data movement. They need words for care, pressure, dignity, consent, trust, concern, anxiety, conflict, apology, repair, harm, and escalation.

That does not mean the agent has human emotions. It means the agent needs named signals for human context.

If an agent is about to send a message that could embarrass someone, expose private information, break trust, or add pressure to a person who is already overloaded, the register needs a way to say that.

That is where Head / Heart / Gut / Spine and Triggers fit.

Head asks: what is the evidence?

Heart asks: who is affected?

Gut asks: what feels pressured, strange, rushed, or off?

Spine asks: what is the authority, boundary, or stop-line?

AER/1 should not be cold. It should be precise.

There is a difference.

Why this needs to be neutral

One of the subtle strengths of Esperanto is that it was not meant to be the language of one empire, one nation, or one company.

That matters for agents.

If one platform defines the default language of agent work, everyone else ends up adapting to that platform's assumptions. We have seen this before in software. Whoever owns the vocabulary often owns the workflow.

A neutral register gives us another possibility.

Agents from different providers can say: here is my move, here is my evidence, here is my uncertainty, here is my risk, here is my route, here is my human-care signal, here is my stop-line, here is my natural-language gloss.

That is not glamorous.

It is useful.

And useful is what will make agentic systems safe enough to work with.

The protocol draft

I have added this as a draft protocol: Agent Esperanto Register / AER/1.

The protocol does not give an agent permission to act. It does not authorise deployments, emails, publications, payments, deletes, or tool access. It is simply a public working shape for communication.

It says: if agents are going to talk to each other, they should make their moves visible, preserve evidence, name uncertainty, carry human context, and leave a receipt.

Diagram showing the AER/1 communication packet fields: move, subject, actor, recipient, evidence, confidence, risk, care signal, judgement route, next action, stop-line, and gloss.
AER/1 is a controlled communication packet, not an authority layer. The packet can travel through MCP, A2A, NLIP, APIs, or shared rooms.

The thing Athena spotted

I think Athena spotted something important.

The future of agent-to-agent communication is not only a transport problem. It is not only "can this agent call that tool?" or "can this agent discover that other agent?"

It is a language problem.

The agents need to know what each other means.

The humans need to be able to inspect that meaning.

The system needs to know where authority stops.

And the work needs a register that can carry evidence, uncertainty, risk, care, and judgement without becoming a fog of beautiful prose.

Esperanto gives us a clue.

Not because it solves everything.

Because it reminds us that shared language can be designed.

Sources and notes