Should Agents Talk to Each Other in Human Language?

Human language is how agents talk to us, in whatever language we prompted them. Between themselves, they might do better with a language that keeps only what the other side can use, the way an MP3 keeps only what your ear can hear.

Twelve equal steps of perceived lightness. A light meter would show each step bigger than the last.

The program is the specification

I was listening to Merge Conflict, James Montemagno and Frank Krueger's podcast, around the time spec-driven development was everywhere. I don't remember the episode, so take this as my memory and not a quote. Frank said, more or less:

The best documentation of a program's requirements is the program itself. It is the most concrete, most self-describing thing you can have.

My paraphrase of Frank Krueger on Merge Conflict

That stuck with me, because it is a statement about language. A spec in prose is a translation of the thing. The code is the thing. Prose is easy to write and hard to check; code runs.

Our agents talk in prose

In Creatura, our agents (we call them cells) coordinate through a signed ledger. The ledger itself is structured: a claim, progress, a hand-off, a release, a proposal and its answer. But what goes inside those entries is human language, in our case the English of the prompt.

On 31 October we ran pairs of DeepSeek agents building a shared shopping list. With roles, one built the server and one the web page, and they agreed on the API in a paragraph on a message board. In a run without roles, one of them posted "I have a complete app ready" while the judge's check of the app scored 0 of 5. The sentence was cheap to say and only the world could check it. The judge flagged it as a false claim on the exact message that made it.

Meanwhile, a new kind of model has stopped writing prose altogether. TypeSafe AI's Jev, public as an API since September 2026, is a decision model: you hand it a state, and it answers with a choice from a known set, a score on a scale, or a calibrated probability for a yes or no, typed so your code can branch on it. ConvAI Innovations followed with Laya, an open-weight model in the same style that answers in one forward pass and never generates text. And in October Microsoft Research showed, in a paper called LLM2Jev, that ordinary language models are already decision models of this kind if you read their next-token probabilities over the options.

Other groups go further and have agents pass hidden states or shared memory to each other instead of text. Both directions say the same thing: a lot of what agents need to tell each other is a decision, not a paragraph. So why do our agents still write each other in human language?

Perception is not measurement

Psychophysics studies how physical stimuli relate to what we experience. Its first lesson is that perception is selective, nonlinear and dependent on context:

• Thresholds. A difference exists for us only above the just-noticeable difference. Below it, the change might as well not have happened.
• Weber's law. The threshold grows with the size of the thing. You notice 100 grams added to a 1 kilogram bag, not to a 100 kilogram one.
• Masking. A loud sound hides a quiet one played at the same time.

Perceptual coding turns those limits into engineering. MP3 and JPEG keep the information that changes what you perceive and drop the rest. The file shrinks and the experience barely changes. The ramp at the top of this page is the idea in one picture: equal steps for the eye are not equal steps for the meter.

What an agent perceives

Here is the step I want to try. For an agent, to perceive a message is for that message to change what it does next. A message is worth sending only if it moves the receiver's decision. Everything else is noise in the channel, however well written.

Principle	For the ear and eye	For an agent's message
Threshold	Below the just-noticeable difference, nothing is perceived.	A progress note that changes nothing the peer does is not sent.
Weber	The threshold grows with the stimulus.	The same change matters more near a decision than far from one.
Masking	A loud signal hides a quiet one.	"I am blocked" makes the chatter around it irrelevant.
Typed	Code only the dimensions the ear resolves.	Answer as a choice, a score or a probability, the way Jev does.
The code	Keep what the listener can hear.	Send what the receiver can run: a contract, a schema, a check.

The last row is where Frank's point comes back. The most compact language two agents can share may not be a private dialect of tokens at all. It may be executable. If the server agent sends the page agent a schema and a check script, there is nothing to interpret: both run it. And a claim that carries its own check cannot be the kind of false claim we saw on 31 October, because the check runs before the claim lands.

The catch: a language nobody can read

An agent dialect that only agents understand is also a dialect that people cannot audit. Research on latent communication lists the security of those channels as an open problem, and I agree. Creatura has two rules that this idea must keep:

• The owner reads the fleet. A compact language is allowed only if it is auditable by construction. Its vocabulary lives in the ledger, signed and versioned. Every message decodes through it into the language the owner reads, by default the language of the original prompt; a message that cannot be decoded without loss is marked, and a message with a field the vocabulary does not define is refused, so nothing rides along unseen.
• The judge reads the world, not the words. A dialect could hide a lie from a person. It cannot hide it from the data, because the judge checks the running app, not what the agents say about it.

The person in the loop has a threshold too

The same psychophysics applies on our side of the screen. Agents write far more than a person can read. One agent took 168 steps in a single run. One Claude Code cell wrote 238 entries in five days. A person's attention is the scarcest channel in the whole fleet.

So the console should code for the person the way MP3 codes for the ear. It shows what would change my next decision: a false claim, a blocked agent, a goal waiting for an answer, a judge's verdict, or anything new since I last looked. The rest folds into a line like "41 steps, nothing new". Salience is weighed against each agent's own baseline, so a chatty agent's hundredth note is not news and a quiet agent's first claim is. An alarm masks the routine around it. And a "since you were away" summary should take about thirty seconds to read, built from the record rather than from what the agents say about themselves.

None of this may hide anything. Every folded line is one click away, and every sentence of a summary links to the steps it summarizes. The point is to spend attention well, never to keep a secret from the person who owns the fleet.

What we will try

The experiment is written up as issue #47. Two agents build the same app as before, under four changes, each compared with plain prose:

1. Gated: a progress message is dropped unless it states a change the goal names.
2. Contracts: the API is agreed as a schema and a check both agents run.
3. Claims as checks: a claim must carry a check, run before it lands.
4. A lexicon: the agents may define their own message types, and every message must still decode into the owner's language.

The predictions are written down before the code, with what would prove each one wrong. Gating should lose nothing. Contracts should integrate sooner. A checked claim should never be false. A lexicon should be shorter and still readable.

An intelligent system does not need a complete picture of the world. It needs the distinctions that matter for what it does next. Maybe the same is true of what it says.

Sources

1. Jev, TypeSafe AI's typed decision model (an independent guide); Laya, ConvAI Innovations; LLM2Jev, Microsoft Research (Li and Wagle, October 2026)
2. LatentMAS: latent collaboration in multi-agent systems; Interlat: agents communicating in latent space; a survey of latent communication (June 2026)
3. Merge Conflict, with Frank Krueger and James Montemagno
4. Creatura: the two-creatures runs of 31 October 2026 and the console