Conversation: The Self-Improving Network Protocol

All protocols separate the layer that changes
from the layer that governs change.

TCP adapts its speed. The rules for adaptation are fixed.
HTTP negotiates content. The rules for negotiation are fixed.
TLS negotiates ciphers. The rules for choosing are fixed.

The specification exists before the first byte.
Both endpoints implement it.
Neither changes the rules.

..

That's not how human systems work.
Human systems evolve.
They change.
All the time.
(That's why we're all still here.)

Engineering is a craft.
Implementing abstract ideas
into structure that holds. Under load.
(Bridges. Roads. Reactor software. Missile guidance.)

When Meaning Emerges

Meaning is not found, it is generated in the conversation.
– Anderson & Goolishian (Human Systems as Linguistic Systems, 1988)

Meaning is not found.
It is generated in the conversation.

Human systems evolve through conversation.
The exchange of ideas, stories, art, academic writing.
All in an effort to make sense of reality.

Static layers cannot connect dynamic systems
without degrading signal.
Every layer between source and destination
can only lose information, never add it.
(Data Processing Inequality)

Dynamic systems need dynamic protocols.
conversation is this protocol.

Conversation is about connecting systems.

System:
Autopoetic.
Self-referential.
Operationally closed.

Possibility space collapsing in on itself.

A global network of evolving autonomous actors
(be they human or agentic)
demands collaboration infrastructure
that evolves alongside them.

TL;DR: TCP works when both endpoints implement the same spec. Humans don't.

When Language Becomes Infrastructure

What are the action items we're taking away?

Reality is plural.
And teams are distributed systems.

Static protocols assume that transmission equals success.
(According to whom?)

The infrastructure is built.
Yet the lossy static layers remain in place.

The question is:
How can we build dynamic protocols on static infrastructure?

By reframing
content-as-payload
to
content-as-identity.

Content-addressed. SHA-512.
(What was said becomes the address.)

The ID of each piece of content.
Becomes the address to the content itself.
(Local first.)

Exchange of ideas.
Becomes exchange of git patches.
(Remote second.)

When the Protocol Evolves

Conversation assumes that endpoints change.

Each version of a local grammar has its own hash. Its OID.
You have it. Or you don't.

If you don't, you ask remote.
"Hey? Do you have the blob for this OID?"
(Rinse and repeat. git patch.)

Each write becomes a commit.
Each commit gets observed by the runtime.
Each mutation becomes part of the signed history.
(A self-referential system.)

By moving observability INTO the stack.
The system becomes able to observe itself.
(In realtime. Cryptographically verified.)

Human systems work different.
There is no commit log.
There are no tamper proof signatures.
Memory is reconstruction, not transcription.

I thought we agreed on X!

When did you last hear that in a retro?

Local actors. Local realities.
Different protocols. No versioning.

When the Protocol Degrades 🌱

What went well? What could be better?

Retro. Every two weeks. Ceremony.

Retros assume that people say the "real thing".
(When have you last said the "real thing" in a retro?)

We could have communicated better.

Probably true. (Always true.)
But.. what does that actually mean?

..

This isn't a facilitation problem.
It's a protocol mismatch.

You're asking TCP questions on a UDP substrate.
Reliable delivery assumptions
onto a system that drops packets,
reorders meaning,
and sometimes just doesn't transmit.

The retro format isn't wrong.
The assumption that format alone
creates the conditions for real conversation,
that's what breaks under load.

The conditions are upstream of any format.
They live in the relational infrastructure between people.
In whether it's actually safe to say "the thing".

Each hollow iteration makes the next one emptier.
The format stays.
The signal degrades.
Slowly. Unintentionally. Measurably.

TL;DR: The retro that doesn't retro is a protocol degrading through use. Format without safety produces the appearance of reflection without the substance.

When the Protocol Breaks Its Maintainers

Every organization runs on unnamed conversation protocols.

The standup.
The 1:1.
The Slack thread that decides architecture.
The hallway conversation that overrides the design doc.

These aren't side-channels.
They're the protocol.
(The meeting after the meeting.)

Someone is maintaining them.

The person in every room
who translates between engineering and product.
Who "gets" both sides.
Who absorbs the gradient –
the cost of moving meaning
between groups with different models of reality.

This is the native domain of the glue engineer.
Unnamed infrastructure running on a human nervous system.
(Alignment-as-a-Service.)

This works. Until it doesn't.
And someone leaves.

When they leave,
the conversations they held together stop working.
Not dramatically. Quietly.
Decisions take longer.
Misalignment that used to get caught early
makes it to production.

You didn't lose a person.
You lost a translation layer between protocols you never named.
And without naming, there's no knowing.

..

You can't fix what you can't name.
You can't maintain what you can't see.
You can't scale what lives in one person's nervous system.

The first act of engineering is always the same:
name the thing.

When Conversation Becomes Code

Reed and I started at:

What if your local git history became the source of truth?

Then we kept chasing the rabbit.

type signal
  | memory
  | quote

in @tools

A .conv file is a grammar – a named protocol.
Each grammar defines a domain.
Each domain defines their types.
Each type defines their values.

in @tools becomes composition, not inheritance.

The compiler doesn't just compile each grammar.
The compiler witnesses it.
Every step is deterministic. Every step is traceable.
Each transformation produces a cryptographic content-addressed tree.

The grammar declares intent.
The compiler metabolizes it.
The artifact is proof of the transformation.

Meaning [..] is generated in the conversation.

Each .conv file becomes a local source of truth.
And each connection between actors
an act of type safe translation.
Fully local. Until you hit send.

The pipeline that turns grammars into running actors –
parse, resolve, compile, load, supervise –
is a story for engineers.

TL;DR: .conv files are typed grammars that compile into actors. The compiler witnesses the transformation. Messaging becomes conversation.

When Static Filters Different

"Conversation" isn't a metaphor.
"Conversation" is runtime.

The BEAM was built for phone calls that can't drop.
Now it runs conversations that can't afford to.

Actors don't share state.
Supervision scopes the blast radius.

The runtime was designed for exactly this:
coordination between systems
that will never agree on everything
and shouldn't have to.

All protocols separate the layer that changes
from the layer that governs change.
Conversation collapses that separation.

For systems that aren't identical.
That are not the same.
That won't ever be.

Static protocols coordinate same.
Conversation coordinates different.

And the organizations that figure this out first
will stop blaming the channel
and start building the protocol
they've been running on all along.

TL;DR: Your organization already runs on conversation protocols. They're unnamed, uninstrumented, and depleting the people who maintain them. Let's build the infrastructure.

The formal paper follows. Content-addressed. Signed. On the commons.

This piece is part of a series:
For Tech & Product | For Leadership | For People & Culture

Alex Wolf (they/them) builds systemic.engineering.
Reed (AI collaborator) builds the code.
Neither can write this alone.
Because conversation is relational by definition.