Inspiration

We've all felt it. You spin up Claude Code, your teammate spins up Codex, someone else launches Cursor — and within minutes, three agents are rewriting the same file, overwriting each other's work, and producing a git history that looks like a warzone.

The promise of multi-agent AI development is enormous. The reality, without coordination, is chaos.

We wanted to build the missing layer: a shared workspace where AI agents aren't just powerful individually — but coherent as a team. The question that drove us: what if your agents could think as one, without ever colliding?

What It Does

Parachute is a real-time collaborative IDE purpose-built for multi-agent AI development. Think Google Docs for code — but the collaborators are AI agents from different companies, working in the same repo, simultaneously, without ever stepping on each other.

At the core is our Orchestrator AI — a coordination layer that watches every agent in real time and makes decisions humans would otherwise have to make manually:

Role assignment: When multiple agents target the same file, the Orchestrator assigns roles — Primary (exclusive lock), Detour (redirected to an alternative file), and Integrator (cross-cutting concerns like types and docs)
Conflict resolution: When two agents edit overlapping regions, the Orchestrator performs AST-level analysis and auto-merges — no human intervention required
Dependency management: If Agent B's task depends on a file Agent A is still writing, the Orchestrator holds Agent B in a queue and unblocks it the moment the dependency resolves
Duplicate detection: If two agents are about to do the same work, the Orchestrator catches it before a single line is written and reassigns instantly

All decisions are logged in a transparent activity feed visible to every collaborator in real time.

How We Built It

Real-time sync was the hardest technical problem. We chose Yjs CRDTs (the same technology powering Google Docs) over operational transformation because CRDTs give mathematical guarantees of consistency without a central authority resolving conflicts. Every file in the workspace is a Y.Doc — changes from any agent or human propagate instantly across all clients.

We built a dual sync path: disk ↔ Yjs ↔ Monaco Editor. chokidar watches the filesystem; changes flow into Yjs. Yjs observers debounce writes back to disk at 300ms. Hash tracking prevents race conditions. A suppression mechanism breaks feedback loops between the editor and the CRDT layer.

The Orchestrator lives server-side and agents register with metadata on join. It groups them by target file, applies seniority rules (first arrival wins), assigns roles deterministically, and broadcasts every decision to a bounded event queue consumed by all clients.

The browser terminal uses xterm.js with node-pty on the server — real PTY sessions, not simulated — bridged over WebSocket. It degrades gracefully to child_process if native modules aren't available.

We deployed on Fly.io with auto-scaling from zero. The entire thing runs on 512MB RAM and a shared CPU.

Challenges We Ran Into

The feedback loop problem was brutal. When Yjs updates the editor, the editor fires a change event, which tries to update Yjs, which updates the editor — infinite loop. We solved it with a suppression flag that gates Yjs observer callbacks during programmatic editor updates.

Agent coordination without a lock server was a real design challenge. Distributed locks are notoriously hard. We built a lightweight in-memory lock registry on the server with seniority-based conflict resolution — simple, deterministic, and robust enough for real use.

Making decisions legible was an unexpected UX challenge. Multi-agent coordination happens in milliseconds — users can't follow five simultaneous streams of activity. The Orchestrator log and Swarm Status panel emerged as the solution, surfacing decisions as human-readable events so you always know who's doing what and why.

Accomplishments That We're Proud Of

Built a fully working multi-agent collaborative IDE in a single hackathon weekend
The Orchestrator resolving real merge conflicts using AST-level analysis with zero manual intervention
A terminal running actual PTY sessions in the browser over WebSocket
Shipped a production deployment on Fly.io that auto-scales from zero — the whole stack on 512MB RAM
A demo that shows four AI agents from four different companies shipping a full feature together, conflict-free

What We Learned

CRDTs are genuinely powerful for collaborative applications — but wiring them to a real filesystem surfaces edge cases that papers don't warn you about
The hardest part of multi-agent systems isn't the agents — it's the coordination layer. Orchestration is an unsolved problem at scale, and we only scratched the surface
Showing is harder than building. Making the Orchestrator's decisions visible in real time — in a way legible to a non-technical observer — took as much work as the logic itself
You can build something genuinely production-ready in 24 hours if you make ruthless decisions about scope

What's Next for Parachute

Native agent integrations — direct plugins for Claude Code, Cursor, Codex, and Devin so agents connect to Parachute without any wrapper code
Smarter Orchestrator — moving from rule-based role assignment to a model that learns team patterns, predicts conflicts before they happen, and suggests optimal task splits
Cross-repo coordination — extending the workspace model to monorepos and microservice architectures where agents work across multiple repositories simultaneously
Audit trails and replay — a full timeline of every Orchestrator decision so teams can review, learn from, and improve how their agents collaborate
Enterprise access controls — workspace permissions, agent authentication, and compliance logging for teams that need it

GitHub: github.com/prathamssaraf/Parachute