Forchetta

Run several Claude Code sessions in the same repo. They won't step on each other.

When two sessions reach for the same file, Forchetta makes one wait, tells Claude why, and lets it go on by itself when the file is free. Every session on your Mac, in one window.

View on GitHub

Then forchetta setup. Free and open source, Apache 2.0. macOS 12 or later. Everything runs on your Mac.

Two sessions, one file. Play it with the guard, then without.

retries

idle~/shop

src/api.ts

free

rate-limit

idle~/shop

Two Claude Code sessions in the same folder, each asked to change src/api.ts.

A scripted replay with stand-in sessions. What the guard tells Claude, and the message that lets it go on, are the ones Forchetta really sends.

One folder, no worktrees needed

The usual way to run agents in parallel is a git worktree for each one. Then each worktree needs its own dependencies, its own .env and its own dev server, and you merge at the end.

Forchetta lets sessions work side by side in one folder. It sees every edit before it happens, for every session, also those started with plain claude.

  • One file, one session at a time: a session holds a file it wrote in its turn. Another session that tries to edit it is stopped, and Claude is told why.
  • It goes on by itself: when the turn that held the file ends, the session that waited is told the file is free, and picks up where it stopped.
  • git that asks first: a git checkout, reset --hard or stash that would change the files under another session asks you before it runs.
  • You decide: “let it through” in a box lets a session write the file anyway. With the daemon off, nothing is stopped.

Every session at a glance

Forchetta listens to the hooks of Claude Code, so it knows what each session does the moment it does it. Sessions you start anywhere show up by themselves: in the Terminal, in iTerm, in an editor. Each box tells you what it is doing, what it was about, how full its context is, what it costs, and what its subagents are up to.

Forchetta6 sessions

shop-api

working

Edit src/routes/orders.ts

Adding retries to the order client, then the tests.

42% · 420k
≈ $1.84cache 54 mintmux

blog

working

Bash npm run lint

Moving the posts to the new layout.

rm -rf dist && npm run build
answer it here
18% · 180k
≈ $0.62cache 58 mintmux

docs

idle

turn finished

Rewrote the install guide and checked every link.

31% · 310k
≈ $0.97cache 41 mintmux

data-pipeline

compacting

compacting, as you asked

Migrating the jobs to the new schema.

86% · 860k
≈ $4.10cache 59 mintmux

auth

waiting

Question: OAuth or API keys for internal clients?

Designing the login for the internal tools.

15% · 150k
≈ $0.40cache 55 mintmux

infra

working

Bash terraform plan

Checking the staging changes before the deploy.

23% · 230k
≈ $0.75cache 57 minread only

A replay of the app's grid, with made-up sessions. Answer blog's permission when it asks, or hover a box for compact and clear. infra was started with plain claude: Forchetta shows it, but can't type into it.

Four terminals, side by side

Click a box and its terminal opens next to the others, a real one you can type in. Sessions started with forchetta run claude, or from the app, live in Forchetta's own tmux: closing a pane, or the whole app, never ends them.

The Forchetta window: a column of sessions on the left, three terminals open side by side, one session waiting for a permission.
Three sessions open, the others in the column on the left. The one waiting for a permission can be answered from its box.

Act without switching windows

  • Answer permission prompts from the box: allow once, deny, or pick one of the lasting rules Claude Code offers. The terminal shows the same prompt, and whichever answers first wins.
  • Send /btw, /compact and /clear to one session, or to several at once. Forchetta types a command only when it is safe: the session is idle, nobody is typing, the prompt is empty.
  • Ask about what you select in a terminal: that session explains it, or it goes to another session.
  • Start a new session in any folder, with a first prompt, a model, a permission mode, or a git worktree of its own.
  • Name your sessions, group them, give them roles, and see them as an org chart. Search earlier sessions of a project for what was asked, decided or changed.
A box waiting for a permission: the command in full, Allow, Deny, and a lasting rule to choose.
A permission, answered from its box.
The panel that sends /compact to three sessions at once, with their context.
One command to several sessions.
The panel of a new session: folder, model, permission mode and first prompt.
A new session, with its model and its mode.

Teams of agents that work together

Start a team from one panel: a lead, which is a Claude session or you, and up to six members, each a Claude Code session with its own role. The lead splits the goal into numbered requests, and each member gets its own as a new prompt as soon as it is free.

  • Real tools, not copy and paste: the lead sends requests and waits for the answers through a small MCP server of Forchetta; a member that is stuck asks the lead a question.
  • ⇄ answers or → executes: for each member, choose whether its final message goes back to the lead or it just does the work.
  • A worktree each, if you like: every member can work on a branch of its own, and the lead merges the work when it is good.
  • Templates: developer + reviewer, a feature squad, research + writing, or a team you saved.
A team at work, from the template to the answer for you. Recorded in the repository's simulation: the app, the daemon and the queue are real, the sessions are scripted stand-ins for Claude Code.

It tells you when you're needed

  • A notification and a badge on the Dock when a session waits for you, seems stuck, or stops on an error.
  • A warning when two sessions write to the same file, or to the same repository.
  • For each session, the files it changed: its own edits one by one, and the diff since the last commit.
  • An icon in the menu bar, and a shortcut from anywhere: ⌃⌥F.

How it compares

Claude Code has its own ways to run several sessions, and there are good tools built around it. Forchetta is made for one way of working: several Claude Code sessions in your terminals, on one Mac, that you want to watch and coordinate.

  • Agent View (claude agents) is Anthropic's full-screen list of your background sessions, in the terminal. Forchetta is a window that stays open next to your work, with a live box for each session and up to four terminals side by side.
  • Claude Desktop is Anthropic's app, with parallel sessions in its sidebar. Forchetta works with the claude CLI you already run in your terminal, with your hooks and settings.
  • Agent teams, experimental in Claude Code, are a lead session that spawns teammates and shares a task list with them. In Forchetta, teams are set up in a panel and saved as templates, with a role, model, permissions and worktree for each member, and the lead can be you.
  • Conductor and similar Mac apps run several coding agents, each in an isolated workspace. Forchetta doesn't host your sessions: it sees the ones you start anywhere, and lets them share a folder safely.
  • cmux and Claude Squad are terminals and session managers for many kinds of coding agents. Forchetta is built for Claude Code only, through its hooks: a guard that keeps two sessions off the same file, permissions answered from the box, context and cost per session, subagents, teams that talk through an MCP server.

They don't rule each other out. Sessions started in any terminal show up in Forchetta, read only unless you started them with forchetta run claude.

It stays on your Mac

The hooks talk to a small daemon that listens on 127.0.0.1 only. Your sessions are not sent anywhere. The one network call Forchetta can make is an optional one-line summary from the Claude API, off unless you turn it on.

Before it changes ~/.claude/settings.json, Forchetta shows you every change, asks, and keeps a backup. Your other hooks stay exactly as they are, and forchetta hooks uninstall takes its own away.

Install

With Homebrew, on macOS 12 or later. No clone, no Xcode, no Apple account.

  1. Install Forchetta. Homebrew brings Node.js and tmux with it.

  2. Build the app on your Mac and add its hooks to Claude Code. You see every change to your settings first.

    Built on your Mac, the app opens with no warning from macOS. Run it again after brew upgrade forchetta.

  3. Open the app. Sessions already running appear on their own.

    To open a session's terminal from the app, start it with forchetta run claude, or with New session in the app.

Forchetta works with arricurdAI too: with it, every box shows when its prompt cache expires, the top shows the cost of the day, you can search earlier sessions, and a /clear from the box leaves a note for the new session.

The manual explains everything step by step. The README is in English and in Italian, and CONTRIBUTING.md explains how to build Forchetta from source.

The guard Teams of agents Command line Configuration Troubleshooting