Running multiple AI coding agents on the same project has always meant choosing between isolation and coordination. Worktrees let each agent operate independently but duplicate the codebase. A single checkout avoids duplication but creates conflicts when agents edit the same files. Crew, a new open-source tool, takes a different approach: let the agents talk to each other.
How agents share context
Crew installs hooks into Claude Code, Codex, and OpenCode that inject live context about what other running sessions are doing. Every new session opens knowing the status, recent activity, and transcript tail of every other agent in the crew. When an agent starts editing a file, the other agents see that activity and can steer around it instead of colliding.
The shared context refreshes automatically. Before each user message, the picture updates. After tool calls, the picture updates. When an agent finishes a turn, the picture updates. The goal is that no agent operates stale information about what its peers are working on.
This coordination happens without worktrees. All agents operate from one checkout, and the context sharing prevents them from stepping on each other's changes. The analogy the project uses is autonomous cars: they do not need separate lanes if they can see what the other cars are doing.
Agent-to-agent messaging
Beyond passive context sharing, Crew lets agents send messages to each other. The crew send command drops a message into another agent's context within seconds, even mid-turn. The sender is identified automatically by walking up the process tree, so agents never have to identify themselves.
Delivery timing depends on what the target agent is doing. If it is busy with a tool call, the message arrives after the next tool call completes, typically within seconds. If it is finishing a turn, the message arrives at turn end and the agent acts on it before going idle. If it is idle, the message waits in an inbox until the next user prompt.
The --kickstart flag changes this behavior. A kickstart message does not just sit in context. It forces the target agent to continue working and act on the message rather than going idle. For OpenCode, which runs inside a single process, a kickstart wakes an idle session within about 15 seconds. For Claude Code and Codex, which do not expose an API to inject prompts into idle sessions, the kickstart catches the agent at the moment it would stop and prevents it from idling.
Broadcasts work too. crew send --all drops a message into every other session, useful for announcing a deploy or a breaking change that all agents need to know about. Messages can expire with a TTL, defaulting to 24 hours, so undelivered mail does not accumulate indefinitely.
Token frugality and safety
Crew is designed to minimize its impact on token budgets. When no other sessions are running, the hooks emit nothing. When the crew status has not changed since the last emit, determined by a per-session hash, the hooks emit nothing. The PostToolUse and Stop modes do the bare minimum: refresh the live registry and check one inbox, with no transcript scan and total silence when there is no mail.
Tails are short in hook mode, five entries per session truncated, and capped at eight sessions. The hook always exits zero, so a broken or slow read can never block a prompt, a session, or an agent's turn. The auto-install merges into existing Claude and Codex hook settings and refuses to write over a file it cannot parse.
For developers worried about the hooks interfering with their workflow, the design constraint is explicit: crew should never be the reason an agent fails or a prompt hangs. The read-only approach to transcripts and the fail-safe exit code enforce that constraint.
Installation and what it wires up
A single npm install -g command wires the hooks into Claude Code, Codex, and OpenCode. For Claude Code, it modifies ~/.claude/settings.json. For Codex, it modifies ~/.codex/hooks.json. For OpenCode, it drops a generated plugin into ~/.config/opencode/plugins/. The plugin runs inside the OpenCode process and shells back out to the crew CLI with the same payloads, so upgrading crew upgrades running plugins without a reinstall.
The hooks register for four lifecycle events: SessionStart, UserPromptSubmit, PostToolUse, and Stop. SessionStart opens every new session with knowledge of the crew. UserPromptSubmit refreshes the picture before each message. PostToolUse handles mail delivery for busy agents. Stop handles mail delivery for agents finishing their turns.
A human-facing CLI provides visibility into all running sessions. Running crew shows every session's status, recap, and transcript tail. The --json flag outputs newline-delimited JSON for scripts and other agents to consume. The --dir flag filters to sessions under a specific directory.
What this enables for multi-agent workflows
The practical value is that developers can now run Claude Code on one part of a codebase while running Codex on another, with both agents aware of each other's work. When Claude Code starts refactoring a shared module, Codex sees the activity and avoids that file until the refactoring completes. When a developer wants to hand off work from one agent to another, crew send delivers the context directly.
This is not full autonomous agent coordination. The agents do not negotiate or plan together. They share status, exchange messages, and avoid collisions. But that level of coordination, which was previously impossible without manual intervention, changes how multi-agent development workflows can operate. The project is MIT licensed and available on GitHub for anyone who wants to run multiple coding agents on the same project without the overhead of worktrees.