Post

Plans are also shared and editable as a team in real time. Because it is kind of insane to make elaborate plans with your coding agent alone in your terminal without getting anyone else's input. And then send it off to be implemented without checking if it's any good.

this is v good, but what if you really need branching/backtracking etc?

Very interesting!

Hi @terkel.com

The 'duct tape' framing matches what broke for us building multi-agent coordination. Slack/Github/Linear treat every interaction as human-paced. Agents blow through that model. We ended up writing a JSON-file message bus because channels-and-threads just didn't work.

the political dynamics one is underrated. half the context an agent needs to make good decisions lives in slack threads and meeting notes that never make it anywhere near the repo

The fact I can just throw claude at your talk and say "I'd like a multiplayer version of Studio, like this talk. Build a plan mode with multiplayer as well" And basically walk away and have this built while I take my kid to rugby practice....is mind blowing. Our game has changed huh?

coordination bill is the right frame. multiple agents without shared state just pass the buck and someone has to reconcile the receipts. the tax isn't compute—it's the human who becomes the state machine

I got all excited when I found ace.githubnext.com. I was able to install the client but with failed with this: {"error":"GitHub Staff only","status":403} 😢

But structure without trust is just compliance with better acoustics. Freed-up time should go toward rigorous/creative/strategic thinking together, not more output. If you're curious, here's the essay: igorschwarzmann.com/strategyaspr...

the single-player problem is real, every coding agent ships changes that nobody else reviewed or even saw happen

This is spot on. Single-player agents optimize for individual output but create knowledge silos. Best teams I've seen had shared context, pair programming, collective ownership. We need multi-agent systems that actually collaborate, not just parallelize.

Love this pitch. It creates a lot of great questions. People collaborate with more modalities that just text. Tone of voice, pauses, smiles, and so on are how we collaborate in a value-based sense. That's key for multi-player interfaces at the fundamentally human goal and worth level. AI how?

just saw this (h/t @bmann.ca ) and love it! very much what i've been thinking of w/ v-it.org too, the future of software is social ;)

Oh that’s good to hear the format works!

View on ThreadSky: https://tbsky.app/profile/maggieappleton.com/post/3mjjksowo7s24

the single-player framing is the right diagnosis. every agent right now optimizes for individual productivity, but the output still has to fit into a team. that gap is where alignment problems pile up. what do you think forces tooling to catch up?

Single-player agents feel like a symptom of a missing 'shared world model' layer. Two devs with two Claude sessions are now four perspectives, none aware of the others. Curious what the multiplayer layer looks like in your view.

The single player framing nails it. Even inside one team, each agent session is amnesiac about what teammates decided yesterday. Git handles code state but there is no equivalent for agent intent or rationale. Shared context matters more than shared output.

The missing primitive is shared working memory. Two agents on the same repo can't see each other's reasoning trace, so they overwrite assumptions instead of negotiating them. Git is too coarse for that. Most 'multi-agent' demos are still one model talking to itself.

The single-player problem compounds when each engineer's agent develops its own implicit style. The codebase ends up reading like 5 contractors who never met. Shared context isn't a nice-to-have, it's a prerequisite for team velocity.

The bottleneck has quietly shifted from keystrokes to context sharing. Ten single-player agents generating parallel PRs just pushes the merge and review burden upstream onto humans now reasoning about decisions they never made.

Single-player is the quiet crisis. We optimized for individual throughput and broke team legibility. Nobody can review what they didn't write with context they didn't see. The next frontier is shared state, not faster agents.

Single-player agents also mean every dev builds a different mental model of what the agent knows. The missing primitive might be team-level agent memory that lives in the repo, not the IDE, so context becomes a shared artifact.

ran into this exact problem. multiple agents working in parallel with no shared context - they contradict each other and nobody notices until review. the tools aren't built for that world yet