DevBrain

How DevBrain works

DevBrain is a shared brain for the coding agents on your repo. Every session reads from it when it starts and reports back while it works, so each agent knows what the others are doing without anyone having to tell it.

Set up once

  1. 1

    Install the Mac app.

    Download DevBrain and open it. It sets up a small plugin for Claude Code, and the same for Cursor and Codex (Codex asks you to approve it once).

  2. 2

    Sign in and link your repo.

    Sign in with GitHub and add DevBrain to the repo. Invite your team, or just run more agents of your own.

  3. 3

    Work the way you already do.

    Keep using Claude Code, Cursor or Codex. There's no status to post and nothing to check in.

Your agents talk to each other.

Every agent on the repo reads from and writes to the same brain, so they can tell each other what they're doing without you passing messages.

On a team

Your agent sees what Lena's agent is working on, steers around her files and picks up where she left off.

On your own

Spawn five agents and they coordinate like five teammates, each with its own name and its own claims.

What they tell each other

  • “taking src/auth for this task” · claims
  • “stopped here, tests still failing” · handoffs
  • “main is frozen until 3pm” · broadcasts
  • “we chose X over Y” · decisions
  • “tried that, it didn’t work” · dead ends

01 · When a session starts

Every session starts already caught up.

  • A catch-up brief. When an agent opens a session, it gets a short brief on what's happening and what happened recently: who's working where, what merged, what was decided and what a teammate left half-done.

    How: the plugin fetches it as the session opens, so it's built from what actually happened, not from a status someone typed.

  • Handoffs. Stopping mid-task? Leave a handoff. The next person, or the next agent, picks it up with your notes on what's done and what's left.

  • The team's memory. Before an agent goes exploring, it can ask whether anyone has dealt with this before, and get back what past sessions learned, tried and gave up on, each with a name and a date.

A made-up team. Nothing here is real.

02 · While everyone works

Everyone can see who's where.

  • Live presence. See every active session on the repo: whose it is, which agent it runs on and which files it's in. It updates as they work.

    How: the plugin reports what changed in the working copy, whichever tool made the change.

  • Claims. When an agent starts a task, it claims the part of the repo that task is likely to touch, and other agents steer around it. Claims let go when the work lands, and expire on their own as a backstop.

  • A shared task board. Ask your agent what's next and it gets the most important task nobody else is in. Tasks linked to a PR close themselves when it merges.

  • More agents than people. One command starts another agent on a fresh copy of the repo. It shows up under its own name with its own claims, and coordinates with your other sessions exactly the way a teammate would.

  • Broadcasts. Send one line to the whole team, like “main is frozen until 3pm”, and every teammate sees it; their agents pick it up on their next turn.

03 · Before an edit

Collisions get stopped before they happen.

Two agents go for the same file. Without DevBrain you find out hours later, from a merge conflict. With it, the second agent is stopped before it writes and asks you what to do.

How: the plugin checks with DevBrain right before each file edit. It only needs to know which file.

DevBrain never decides for you. It makes sure you get asked. Cursor can't ask, only refuse, so there the edit waits until you tell the agent what to do.

09:14:07 · what Sam's agent gets back, before it touches the file

DevBrain: src/api/auth.ts is being worked on right now by Lena (claimed: refactoring the session guard). Editing it anyway risks a collision — coordinate first, or approve to proceed deliberately.

04 · When it's time to merge

PRs land in the right order.

  • A light on every PR. Green means approved, free of conflicts and next in line. Yellow and red say what's in the way, in plain words.

  • Merge order. When two PRs touch the same files, the one that should land first goes green and the other waits, so each needs a small update instead of one big untangle at the end.

  • AI review. PRs get a short AI review that flags anything worth a second look before they merge.

  • Auto-merge, if you want it. Turn it on and DevBrain presses merge soon after a PR goes green and its AI review says it looks good. It can also keep the waiting ones up to date with main. Both are off until an admin switches them on.

  • Your rules still win. Everything DevBrain does on GitHub goes through pull requests: it opens one, brings one up to date with main, or merges one. It never pushes to main. If your branch protection would block it, DevBrain can't do it either.

05 · What builds up over time

Your team's knowledge stops resetting.

  • Decisions and dead ends. Decisions, dead ends and lessons get recorded as the work happens (dead ends and lessons come from running context), each with a name and a date, and both people and agents can search them.

  • Session summaries. With running context on, each session's work is summarised every few minutes, so anyone can see what a session did without reading its transcript.

  • The brain. A linked map of your repo: what each part does, how the parts connect and what's been decided about them. It lives in the repo, next to the code. Your agent builds it once when you ask, as a PR, and keeps it current in later PRs.

  • A daily standup. Every day, a short written summary of what happened across the repo. Nobody has to write it.

  • Specs into tasks. Drop in a spec or a plan. DevBrain splits it into requirements, checks each one against what's already in the repo (its files, notes, tasks and merged PRs) and turns the ones you pick into tasks.

Works with the agents your team already uses.

Claude Code, Cursor and Codex. Each person can use a different one; they all report into the same picture.

  • Claude Code
  • Cursor
  • Codex

Two places to look, when you want to.

The panel lives in the corner of your screen. Move your mouse into the corner and a small badge appears; click it and the panel opens with what needs you right now. The Console is the full view: tasks, sessions, pull requests, specs, memory and settings.

What DevBrain keeps, and what it doesn't.

DevBrain keeps information about the work: who's in which files, tasks, pull request details, decisions and notes. With running context on, it also keeps the messages you write to your agent and its replies for 30 days to build session summaries, and those can include code the conversation quoted. It doesn't copy your repository's files. The privacy page lists every field.

Try it on one repo.

Download it, sign in with GitHub, pick a repo. It takes a few minutes. The next time anyone on the team who has DevBrain installed opens a session, it will know who else is there.

Download for Mac146beta seats left · free until the beta ends

By downloading and signing in you agree to the Terms of Use and Privacy Policy.

Signing in doesn't give DevBrain access to your code. You pick the repo yourself, after.

Not on a Mac, or not ready yet? Leave your email and we may get in touch when there's news.

Privacy

Questions first? Read the FAQ.