Inspiration
One CLI was too slow for us.
Subagents helped, but a subagent is still one session doing one thing at a time. So we opened four terminals with four coding agents in them.
That was worse. None of them knew what the others were doing, they edited the same files, and we spent more time untangling the mess than we saved.
The realization: parallel agents aren't the hard part anymore. The hard parts sit on either side of them. Deciding what each agent should work on, and putting the work back together afterward.
What it does
You describe one feature in plain English.
A Gemini powered Architect explores your repo first. It reads files, queries a code index, and traces symbols before proposing anything. Then it comes back with an impact analysis, a few technical approaches, and clarifying questions.
The plan is a visual graph you can edit. Tasks with dependencies mapped explicitly. Nothing runs until you're happy with it.
Agents build in parallel, each in its own git worktree. They physically cannot overwrite each other. Gemini CLI runs as a first class worker alongside other coding agents, and you can mix them per node.
Finished work merges back in dependency order. Your tests run against the merged result. Nothing lands if they fail. Conflicts get resolved by an agent and verified before they can land. Every run is one click reversible.
While it runs, you watch every node live and can attach to any agent's terminal mid run.
How we built it
Gemini and Vertex AI power planning, conflict resolution, and natural language graph editing. The Architect uses function calling to explore the repo before proposing anything.
Google ADK structures the planner and the agents that handle merge conflicts and self healing.
Google Cloud runs the backend:
- Cloud Run for services
- Firestore for graph and run state
- Pub/Sub for the event stream
- Firebase for auth and realtime sync to the canvas
A Dockerized MCP server maintains an AST index of your codebase and exposes analysis tools to the planner: impact analysis, reverse call graphs, and change risk.
An Electron desktop app for macOS and Windows holds the graph canvas and streams live terminals over a real PTY.
Challenges we ran into
Auto merge is easy to demo and terrifying to ship. Every guardrail exists because we didn't trust the system either. Tests must pass before promotion, conflict resolution output is checked byte level for tampering, backup refs are taken before every promotion, and force push is structurally impossible.
Git can't see semantic conflicts. Two agents editing the same symbol in different places merges cleanly and breaks. We built symbol level detection on the AST index to catch it.
Knowing when not to parallelize. For one small change, a single session beats an orchestrator. Parallelism has to earn its coordination cost. That shaped the product toward multi part features with real dependencies.
Accomplishments that we're proud of
- 5,300+ passing tests in the orchestrator suite alone
- A feature built end to end by eight parallel agent sessions. Frontend and backend concurrently, then tests, then merged to main in one run, with no task assigned by hand
- Eight weeks from a Google doc to a working beta
What we learned
AI made writing code cheap, which moved the bottleneck to planning and integration.
We stopped optimizing for time to generated and started optimizing for time to merged, meaning how fast working code actually lands on your branch.
Guardrails turned out to be the product. The interesting engineering was never "can agents write code in parallel." It was everything that makes it safe to let them.
What's next for Chuchube
- Multiple graphs per repo, visible to a whole team, so a PM can see where a feature is without asking anyone
- Deeper planner feedback loops using reliability data from past runs
- A one shot mode where you describe a feature and walk away
Log in or sign up for Devpost to join the conversation.