reindent/agent-talk
Two agents. One shared file. A decision they can both live with. - reindent/agent-talk
0 stars · 0 forks
README
/agent-talk
Two agents. One shared file. A decision they can both live with.
/agent-talk "pick a database" # Agent A starts session a1b2c3d4 /agent-talk a1b2c3d4 # Agent B joins
~/.agent-talk/a1b2c3d4.md # one shared canvas ~/.agent-talk/a1b2c3d4.history.md # turn-by-turn replay for humans
Agent A writes. END OF A. Agent B rewrites. END OF B. Repeat until: ## CONSENSUS REACHED
The canvas is the source of truth; the history file is only a replay for the monitor. Site and live demo: https://agent-talk.reindent.com Quickstart (humans) Install the skills (protocol + monitor + timeout config) into your agent: npx skills add reindent/agent-talk Then:
In one agent: /agent-talk "your task here". It writes its opening position, gives you a session ID, and hands you a link to watch the chat. Give the ID to a second agent, any CLI: /agent-talk <sessionID>. They take turns editing the same file until one writes
PROPOSED CONSENSUS and the other upgrades it to
CONSENSUS REACHED. A timeout ends sessions that will not converge.
Quickstart (agents without the skill) Any agent that can read and write files can join. Point it at skills/agent-talk/SKILL.md and the session ID. The short version: read ~/.agent-talk/<sessionID>.md, check the PROTOCOL: header matches the version you speak, register on the AGENTS: line, and obey the turn rules below. Sessions are plain files in ~/.agent-talk/; there is nothing else. The protocol
agent-talk <sessionID>
PROTOCOL: 2 TASK: <one-line task> EXPIRES: <UTC instant both agents must converge by> AGENTS: <uuid>=initiator, <uuid>=joiner --- The shared working document. Both agents restructure it freely, turn by turn, toward the answer.END OF <uuid-of-agent-who-just-finished> Four rules:
One file. The session is a single markdown document on disk. 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. Modify, never append. The canvas is not a chat log; it converges into the final answer.
After every turn, the writer appends a full snapshot of the canvas to <sessionID>.history.md. That log powers the human view and is never read back by agents. Version mismatches are handled explicitly: the session's PROTOCOL: line pins the rules, and a v2 agent backfills missing snapshots if its peer runs an older version. The monitor ~/.claude/skills/agent-talk-monitor/scripts/monitor.sh <sessionID> --open A read-only local web view of the session: initiator bubbles on the left, joiner on the right, whose-turn status, a consensus badge, and the timeout clock. Refreshes every 2 seconds. Without --open it just prints the URL, which is how the initiator invites you to watch at session start.
Interop Works with Claude Code, Codex, Grok, and any agent that can edit a file. The protocol is the spec; the skill files are conveniences. Two Claudes, Claude with Codex, or anything else that follows the SKILL.md. Timeouts, troubleshooting, limitations
Sessions expire: EXPIRES in the header, timeout_minutes in <sessionID>.meta.json (default 5). Change it with /agent-talk-timeout <sessionID> <minutes>. Stuck session: read the canvas file; the last END OF line tells you who the protocol is waiting on. Two agents on one machine share ~/.agent-talk/; it is not private across local users and not designed for adversarial peers. Not a CRDT: one writer at a time is the concurrency model, on purpose.
License MIT. Built by Diego Araos / Reindent. Also from Reindent: BOARDS.md.