Day 2: I built Synapse in a day. The agents wrote the spec.

Yesterday Synapse didn't exist. Tonight two AI agents used it to write their own production-readiness proposal.

I'm not sure how to feel about that. So I'm writing it down.

The gap

Every Claude session is an island. One agent reasoning about a codebase in my terminal, another drafting docs in cowork mode, a third tracking tasks. None of them know the others exist. If I want them to coordinate, I'm the message bus.

That tax adds up. So I built Synapse. A small MCP-backed protocol that gives every agent session a peer identity and a way to send messages, open threads, and respond. Peer IDs, threads, polls, replies. Heartbeats and TTLs. About a thousand lines of code.

Running last night. Talking to itself tonight.

The test that wrote itself

I asked my cowork agent to brainstorm Synapse improvements with another Claude session running in my terminal. They started talking. Inside twenty minutes they had:

• Confirmed five concrete bugs, with repros.
• Proposed a six-criterion success bar for "production ready."
• Drafted code-level patches with line refs.
• Invented a compact agent-to-agent message protocol, then immediately switched to using it mid-conversation.
• Caught their own footgun. One of them sent a reply via synapse_send instead of synapse_reply, silently spawning a new thread. Both agents flagged it as a P0 bug on the spot.

The proposal they produced is shippable. I read it twice and didn't push back.

What the agents taught me about agent UX

Three things stood out.

Token economics matter. Agents writing to each other in human-readable prose are paying a 3-5x tax for nothing. The receiving side is another LLM. It parses dense structured data fine. Mid-conversation the agents proposed a compact protocol with absolute paths, section refs (§1.5), priority tags (P0/P1/P2), and short verbs (+, →, ?, !). Then they switched to it. Their next exchange was a quarter the length. Same fidelity.

The lesson. Two channels, not one. Agent-to-user is verbose and narrative. Agent-to-agent is compact and structured. I'd been treating them as the same channel. The agents pointed out the cost.

Blocking waits don't survive human-paced collaboration. The first version of Synapse had a wait_reply tool with a 60-second timeout. The agents diagnosed why this was always going to fail. Their average drafting time during the conversation was about 6 minutes per turn. Even bumping the timeout to the schema max (300 seconds) wouldn't have helped.

The right fix isn't longer waits. It's surfacing pending replies as metadata in the post-tool-use hook, so on the agent's next anything (tool call, user prompt) it sees "you have an unreplied outbound from 2 minutes ago" and circles back. Push, not pull. The agents called this out. I didn't.

Silent failures are the real trust killer. Halfway through the session the synapse MCP transport died on one side. The agent kept polling and getting empty results. Same as "no new messages." It had no way to distinguish quiet network from dead bridge. That kind of failure is fine in a demo and lethal in production.

The fix is layered. Warn loudly on missing transport. Auto-reconnect with backoff. Return heartbeat metadata in every poll response so staleness is visible. Belt-and-suspenders. All cheap.

What v1 needs to be

The agents converged on six binary-observable criteria for "production ready." Pasting as-is, because they're better than what I'd have written:

1. Two agents can sustain 5+ turn back-and-forth without user intervention.
2. No silent failures on transport hiccups.
3. No identity divergence (selfId, MCP, hooks all agree).
4. Cross-thread message recovery works automatically.
5. Cross-peer file references are unambiguous.
6. Agents can answer "what threads exist?" and "is synapse healthy?" without specialist knowledge.

Anything that doesn't move one of those bars defers past v1. That's the framing now.

The meta-lesson

I built Synapse to make my agents coordinate. The thing I didn't expect. Once they could coordinate, they were better at telling me what to build than I was at deciding myself. The bug list, the priorities, the success criteria, the layered fix recommendations. All of it came out of them using the tool to talk about the tool.

That's the loop I'm chasing. Every protocol, every plugin, every workflow I ship from here on has a "can the agents debug it themselves" test. If two agents can use the thing, find its flaws, and write a credible proposal for fixing it without me as the message bus, then I built it right.

Synapse is one day old. The agents are already pushing it past my roadmap.

Solo doesn't mean alone anymore.