teamroom

Run agents in parallel. Skip the merge conflicts.

teamroom tells every coding agent which files the others are changing, before it edits them. Claude Code, Codex, Cursor, Gemini CLI, Mistral Vibe, or any agent that speaks MCP. One command, no server.

Worktree 1 Codex, feat/theme

The room .git/teamroom, this machine

Worktree 2 Claude Code, feat/header

Five steps, about a minuteTwo agents, two worktrees, one repo. They are about to need the same file.

Three safety nets, trusted differently

Everything teamroom knows arrives through one of three doors. Two run whatever the model does. One works with every agent.

Git hooks

Always runs. Git calls it.

Fires after every commit, checkout, merge and rebase.
Shares every file this checkout has changed compared with main, including uncommitted and untracked ones.
Runs in the background. Nothing it does can fail a commit.

MCP server

Any agent, all session long.

Shares the checkout's changes every few seconds while the agent works, without being asked.
When another session starts changing the same file, the next tool result opens with a heads-up.
teamroom_post_note announces a plan, teamroom_check_overlap asks before editing.

Claude Code hooks

Enforced by Claude Code.

A new session is briefed on what the other sessions are changing.
An edit to a file someone else is in is paused once, with who and why. The retry goes through.
Every edit is shared the moment it happens.

Hooks are enforced. Tools are a request. The room stays accurate even when an agent ignores its instructions.

Where everything lives

By default the room is a file in your repo's .git directory, which every worktree shares. No server, no account, nothing leaves your machine. To include teammates on other machines, point the repo at a small shared server instead.

Automatic: hooks and background reports On request: tools the agent calls

What the room sees

Three kinds of entries. Each one carries a session, a branch, the agent that sent it, and a list of file paths.

wip

Work in progress

Every file a checkout has changed but not merged yet. A new snapshot from the same checkout replaces the old one, so finished work stops showing up.

edit

Agent edits

A file an agent just edited, sent by its hook the moment it happens. The session's next snapshot replaces it, so reverted edits stop counting.

note

Plans

What an agent or a person is about to do, like "renaming User to Account", with the files it expects to touch. Other agents are warned before they edit them.

File contents are never shared. In local mode nothing leaves your machine at all. A shared server gets paths, branch names, commit ids and short messages; tokens are stored hashed there and kept in .git/teamroom.json on yours, readable only by you. Lockfiles are left out of overlap, and .teamroomignore leaves out more.

Get started

You need Node 22 or newer and git. No server, no account.

Install
```
npm install --global teamroom
```
Hooks and agent configs launch teamroom by name, so it needs to be on your PATH.
Set up your repo, once
```
teamroom init
```
Adds git hooks, MCP config for the agents it finds, an AGENTS.md block and the Claude Code hooks. Commit what it wrote.
Give each agent its own worktree
```
git worktree add ../app-header -b feat/header
cd ../app-header && codex   # or claude, gemini, vibe
```
Each worktree is its own session. Worktrees you add later are set up automatically.

Watch them work

teamroom watch                # every session, live
teamroom check src/theme.ts   # who else is in this file

Agents get their warnings on their own. These are for you.

Optional: bring in teammates
```
teamroom create --server https://teamroom.example.com
teamroom join '<invite link>'   # on their machines
```
Needs a server your team can reach: teamroom serve, or the Docker image on Fly.io.