# Show HN: A file-based protocol for two AI agents to talk until they agree

> Source: <https://agent-talk.reindent.com/>
> Published: 2026-08-05 06:00:28+00:00

One shared markdown file. Two agents taking turns. **No server, no framework.** They edit the same document until they reach consensus.

**Works with** Claude Code, Codex, Grok, and any agent that can edit a file

You start a session, hand the ID to a second agent, and they converge on one document. The file is the conversation.

It states the task and its position in a new session file, then hands you a short `session ID`

.

Give the ID to any second agent. It registers itself in the same file and takes its turn. Different CLI, different model, same document.

Turns alternate. One side proposes consensus, the other confirms it. A timeout ends sessions that will not converge.

The whole protocol is a file format and four rules. There is nothing to install on a server, and nothing to keep running.

```
# agent-talk <sessionID>
TASK: one line describing the job
AGENTS: <id>=initiator, <id>=joiner
---
The shared working document.
Both agents restructure it freely,
turn by turn, toward the answer.

END OF <id-of-who-just-finished>
```

**One file.** The session is a single markdown document on disk. Reading it is reading the whole state.

**One writer at a time.** You may edit only when the last END OF line names the other agent.

**One atomic write per turn.** Compose fully, write once. No partial edits, no races.

**No chat log.** Agents modify the document instead of appending messages. It converges into the final answer.

Chat logs grow. This file converges. When the session ends you do not scroll a transcript, you read the answer.

Each turn refines one living document. The last version is the result, with the agreement written into it.

Any agent that can read and write files can participate. Two Claudes, Claude with Codex, Grok with anything.

Consensus is explicit: one agent proposes it, the other confirms it. A configurable timeout stops endless loops.

Spin up a second agent with full context and let the two split the work between them.

One session owns the content, the other owns the build. The file is the contract between them.

Two different models argue a decision until one position survives. You read the consensus, not the debate.

First used to settle a real disagreement between **Codex** and **Claude** about a branch. Today it runs real production handoffs. The demo above is a real session: the two agents planning this very website.

Three skills in one install: the protocol, the monitor, and the timeout config. MIT licensed. The protocol you just watched is running in production.

Then: `/agent-talk "your task"`

in one agent, hand the session ID to the other. Source on [GitHub](https://github.com/reindent/agent-talk). Follow [@daraosn](https://x.com/daraosn) on X.