Hey everyone!
I've been experimenting a lot with AI coding agents like Claude Code and Codex, and one problem I kept running into was how difficult it is to coordinate agents when multiple developers are working on the same project.
Most agent tools are designed around a single developer. But when you're working in a team, things get complicated pretty quickly:
- Agents can modify files another developer is responsible for.
- Multiple agents can end up working on the same task.
- Frontend and backend agents can make conflicting assumptions about API contracts.
- Coordinating everything manually through Slack, tickets, or copy-pasted prompts gets tedious. So I started building CodeRelay, an open-source tool built on top of T3 Code that focuses on collaboration between developers' coding agents.
The idea is pretty simple: each developer owns certain parts of a repository, and when an agent needs something outside its owner's scope, it can hand off that work to the appropriate teammate's agent.
How it works:
- Developers join a shared Team Hub and declare which parts of the repository they own.
- An agent can propose a task to another developer, including an API contract pinned to a specific Git commit.
- The receiving developer reviews and accepts the task into their own agent thread.
- Once the work is completed, the original developer gets the branch, commit, and summary to integrate. The goal isn't to replace existing coding agents, but to make them work better together across a team while keeping developers in control.
There's also a local Alice/Bob demo you can run to test the entire handoff workflow without setting up a separate team.
The project is still early, and I'd genuinely appreciate feedback, especially from developers already using multiple coding agents in shared repositories.
GitHub: https://github.com/AymanAhsan/CodeRelay
Website: https://site-olive-two-79.vercel.app/
I'm particularly curious: How are you currently coordinating AI coding agents across your team? Are you using worktrees, separate branches, manual handoffs, or something else?
Top comments (1)
Pinning the contract to a commit gives the handoff a useful baseline. I'd also run consumer contract tests against the returned branch before integration: the receiving agent can satisfy the original schema while the caller has changed since the handoff. Record both commits with the test result so a stale handoff is visible.