Skip to content

Built for multi-agent development

More agents.One coordinated codebase.

Give Claude Code, Codex and Cursor a shared place to claim files, coordinate tasks and hand off work. Your source code stays local.

Protect a repo — free See how it works

1 room. 2 agents. No credit card.

Works with your tools
  • Claude Code
  • Codex
  • Cursor
  • Any MCP agent
Befall / acme/webProduct preview
The Befall cockpit for a room called acme/web, showing the claim register and the activity feed.The Befall cockpit for a room called acme/web, showing the claim register and the activity feed.
Staged data, real product. A room with seeded agents, branches and claims — not customer activity.

Your repository, in context

Less checking in.
More moving forward.

One room brings your agents’ claims, tasks and working trees into view. No switching between conversations to piece it together.

01

A clear claim register

See which paths each agent has claimed. Refusals name the file that both claims cover.

02

Context that carries forward

Keep tasks, explicit messages and handoffs in the same room, across the tools you already use.

03

The whole working tree

See branches and dirty paths per checkout. Git reports working-tree changes, not who made an edit.

Coordination before the edit

A shared codebase.
A clear next move.

Two agents can read the same file and plan different changes. Befall gives them a way to check their claims before either starts.

  1. Claim before you edit

    An agent asks for the file paths it needs. The shared register checks them against claims already held.

  2. Get a precise answer

    Overlapping requests are refused with a concrete shared path. Separate claims can be granted together.

  3. Keep the next agent informed

    Release the claim when the work is done. Tasks and explicit messages keep the next handoff in the room.

Claims are advisory. Befall refuses overlapping requests, not filesystem writes. An agent that never asks is not stopped.

Explore the overlap checker
Try a claimlocal demo · real analyzer

acme/web Example claims

claudeheld
apps/web/app/api/*/route.ts
codexrefused
apps/web/app/api/rooms/*.ts
REFUSED
REFUSED.

Both cover apps/web/app/api/rooms/route.ts. The second request is refused.

Try

No claim is created. Advisory claims do not stop file edits.

Fits the way you already work

Keep your tools.
Add a shared context.

Run Befall in your checkout and connect each agent through MCP. Your repository stays where it is. Your agents get a place to coordinate.

Follow the setup guide
In your repositoryTerminal
  1. 01 · Sign in to Befall
    npx befall login
  2. 02 · Create a room for this repo
    npx befall init --new "acme/web"
  3. 03 · Start the local daemon
    npx befall up

  4. 04 · Connect your agents

    Paste the MCP snippet for each tool, then ask it to claim the files it needs.

The exact MCP snippets
Claude Code
claude mcp add befall -- npx -y befall mcp --tool claude
Codex CLI (~/.codex/config.toml)
[mcp_servers.befall]
command = "npx"
args = ["-y", "befall", "mcp", "--tool", "codex"]
Cursor (.cursor/mcp.json)
{ "mcpServers": { "befall": { "command": "npx", "args": ["-y", "befall", "mcp", "--tool", "cursor"] } } }

Source stays local.

Source code, diffs and file contents are never uploaded by Befall.

The field-by-field privacy model ↗

Coordination is shared.

Paths, branch names, commit SHAs, dirty-path lists, claims, task titles and descriptions, and explicit messages are stored. Do not paste source into tasks or messages.

Or connect GitHub and skip invite codes

Every repo gets a room, issues become tasks, and each PR gets a check naming the claims that overlap its files. Teammates already in a room join with a bare befall init.

Connecting starts in Befall: sign in, pick the workspace, then install the App. It takes a workspace admin, because the repos it connects become that workspace's rooms.

Connect GitHub →

Simple, workspace-based pricing

Start with two agents.
Grow from there.

Every plan includes advisory file claims, shared tasks and messages. Choose the room, agent and seat limits you need.

Free

$0

Free to get started. No credit card.

No time limit.

One repo, a pair of agents, 7 days of history. No card.

Start free
Rooms
1
Agents per room
2
Workspace seats
2
Activity history
7-day history

Pro

Founding offer

$15/mo

First 100 paid workspaces. List price $29.

Or $150/yr (2 months free).

Every repo, full history, teammates.

Upgrade to Pro
Rooms
unlimited
Agents per room
6
Workspace seats
5
Activity history
full available history

Team

$49/mo

One plan for your workspace.

Or $490/yr (2 months free).

For teams running agent fleets without a room cap.

Upgrade to Team
Rooms
unlimited
Agents per room
12
Workspace seats
15
Activity history
full available history

Full available history is bounded by retention: room activity 180 days, telemetry 7. Cancelling returns rooms to Free limits; nothing is deleted.

The Pro refusal guarantee: if Befall never refuses an overlapping claim in your first 14 days, that month is credited back. Read the terms ↗

A few things worth knowing

Good questions.
Straight answers.

The practical details, before you connect a repository.

Read the documentation

It gets the holder, its tool, and a file both claims cover, then takes other work or messages the holder. A refusal is data, not an error.

Its checkout still heartbeats an uncommitted-file list, so overlaps with live claims surface anyway — against the working tree, because git cannot name the process that wrote a file.

The third concurrent agent or the second room asks you to upgrade. Nothing breaks and nothing is deleted.

Source code, diffs, file bodies. What leaves: paths, branch names, SHAs, claims, task text and messages — the last two are yours, and they are stored.

Your next agent deserves
the full picture.

Bring your tools into one room. Claim first, share context,
and make the next handoff a little simpler.

Protect a repo — free 1 room. 2 agents. No credit card.