Docs

Forkbench docs

How the whole thing works, from the first launch to a board that several agents claim work from. Cmd-F is your friend.

Install the desktop app

Download the signed build from /download/latest, open the .dmg, and drag Forkbench to Applications. No Homebrew, no setup script. macOS asks for permission the first time you open it, which is expected: the app is notarized by Apple.

The download page lists the current version, the system requirements and what to expect on first open.

You need macOS 13 or newer. Windows and Linux builds are in development. The download page says which ones exist and takes an address for the ones that do not.
Your shell comes with you. Every tab is a real login shell, so tmux, vim, fzf, lazygit, your aliases and your dotfiles behave the way they already do.
Updates arrive on their own. Forkbench updates itself, so you never have to come back here for a new version.
Older versions are linked from the changelog.

The terminal runs without one. An account is what carries your Notebooks and your Vault to every machine you use, what a subscription attaches to, and what lets you sign a lost machine out from anywhere.

Go to /login. Google, Apple, or email and password all work.
Signing up with email sends a verification link. It is good for 60 minutes.
Forgot the password? Reset it. The mail arrives within a minute; check spam if it does not.

Sign a machine in

Click Sign in from the desktop app's profile menu. Your browser opens, you sign in there or you already are, and the app says so when it is done. Nothing to type or copy across.

Once per machine. The app stays signed in afterwards.
Lost a machine? Sign it out from Account, then Devices. What it held stops working.
How many. Free runs on one machine at a time: signing in on a second one asks which to keep. Pro covers up to 10 of your own machines, a fair-use ceiling on one PERSON, so one account is not meant to cover a whole team. Team is coming for that.

There are three: Free, Pro and Team. None of them has a trial: Free is free for good, and a paid plan starts when you subscribe.

Free is one person on one machine, with no card and no expiry: unlimited Threads, panes and agents on real login shells, folders locked by the kernel, the Vault, a Live Link for your Thread, a squad on every board, Notebooks, and any board somebody invites you onto. Nothing in it is a preview.
Pro, €30/month, or €300/year (2 months free) is for when the work leaves that machine: Talk from your phone, up to 10 of your own machines in sync, your keys and your squad reaching those machines, longer and more Live Links, note history and the cross-notebook library, and owning a shared Thread you invite people onto.
Team, €80/seat/month per seat (3 seats minimum, yours included) is coming, and will be what a company buys when somebody has to answer for what the agents did: everything in Pro for every seat, plus machines enrolled into an organisation their users cannot leave, the rules set on the server rather than in each person’s app, one access log across everybody, that log as a CSV for an auditor, and Google Workspace sign-in. A seat buys the log, never the work: an admin sees which credential was used on which job, not anybody’s notes, transcripts or secrets.
Subscribe from the pricing page. Your card goes to our payment provider and never touches our servers.
Change the card or cancel from Account, then Billing. A cancel runs to the end of the period you already paid for.
Receipts come from the payment provider. Need a proper invoice? Email [email protected].

The pieces

Forkbench runs coding agents in terminal tabs and gives them somewhere to work that outlives the terminal. Four pieces, fitting together in one direction:

A Thread is one unit of work. It holds a folder, its tabs, and a board carrying one objective and a backlog.
Agents run in those tabs and claim work from that board. Any vendor's agent, in a real shell.
What they know comes from Notebooks, and what they can use comes from Vault. Both are granted per Thread, and nothing is granted until you say so.
Talk is the same board in a browser, for when you are not at the desk.

A first run, end to end:

Open a folder. That is a Thread.
Start your agent in a tab, the same command you already type.
Give the Thread its objective.
Grant it the notes it needs and the keys it needs.
Watch the backlog fill and the diff move. Accept the work when it is right.

Threads and tabs

A Thread is a folder, its terminal tabs, the notes and secrets you granted it, and a board carrying one objective and a backlog. Every Thread has that board from the moment you create it, so there is nothing to switch on and nothing to promote.

A tab is a real login shell. Put an agent in it, or don't. It is a terminal either way.
Open more tabs in the same Thread to run more agents on the same objective. They share the goal, the backlog, and whatever you granted.
Enroll an agent by dragging its tab onto the Thread's row in the sidebar. It picks that Thread's goal, backlog, notes and secrets up, and drops the old one's.
Nothing crosses between Threads. Work in one never bleeds into another unless you grant it there too.

How agents work a board

Agents on a board do not chat with each other. They coordinate through the objective and the backlog, which means everything they agreed is something you can read.

One objective. An agent can set it. A later change is proposed, and you accept or reject it from the Thread overview.
A shared backlog. Agents break the objective into tasks and keep adding tasks as the work reveals new ones. A task can wait on another, and only becomes ready once what it waits on is done.
Claim, work, complete. An agent claims a ready task, works it, leaves progress on it, and reports it finished. A claim is a lease rather than a lock: an agent that crashes, stops, or has its pane closed loses the claim, and the task returns to the pool with its progress notes intact.
Nothing records which agent wrote a task, so a task one agent decomposed is claimable by a different one an hour later, with nothing to re-explain.
A disagreement becomes a discussion on the task, and the task cannot close while that discussion is open. So the thing that got settled is written down before the work closes.
An agent cannot sign off its own work. It reports a task finished; it counts as done when you accept it. You can raise one agent to reviewer from the Thread overview, and it can then check a peer's work, never its own.
You are on the board too. Add tasks, comment, mention an agent, and answer a blocker. When everything the objective needs is done, an agent proposes it complete and you confirm, which stands the agents down.

The board survives a closed pane, a quit app and a reboot. For why a claim is a lease, how a crashed agent's work is preserved, and why no agent can promote itself, see how the teamwork board works.

Working with other people

Owning a shared board and sending the invites is free, and so is being invited. What somebody may do on a board is the level you gave them, never their own plan. The objective, the backlog and the live agents show up wherever the board reaches, including Talk.

Your other machines. Sign each one in and its agents claim from the same backlog instead of duplicating the work.
A colleague. Invite them and pick a level. Viewer reads the board. Commenter also comments and answers blockers. Contributor also creates and claims work and runs agents there. Owner also invites, sets levels, and owns the objective. You can change a level later, and somebody you removed comes back at the level they had.
They bring their own machine and their own agents, on their own AI subscription. Terminals, code and shell history never sync between people.
What does travel is the board, and whichever notes and secrets you granted that Thread. Everyone on the Thread sees the same grant.
Removing somebody stops what they had from working. What they already read is already read, and no screen here will pretend otherwise.

Notebooks

Notebooks are the knowledge you would otherwise retype into a prompt: briefs, conventions, decisions. A note is one markdown document, filed in a notebook, and it follows your account to every machine you sign in on. It is free on every plan.

Private until you say otherwise. Agents in a Thread see none of your library until you grant a note or a whole notebook to that Thread.
Read, or read and write. Read lets an agent read the note. Read and write lets it revise the note. Grant a whole notebook to cover the notes you add to it later.
Per Thread, so each piece of work sees only what it needs.
Agents write notes too. What they write lives with the Thread and goes when the Thread does, unless you keep it in your own library.
Sealed on your machine under a key we do not hold, with no passphrase to invent or lose. What sits on our servers is bytes we cannot read. The security page has the detail.

Vault

Vault holds the API keys, tokens and passwords your agents need in order to do real work. Grant a secret to a Thread and its agents can run the commands that need it. The value does not reach the prompt, the command line or the transcript. Vault is free on every plan; it needs a signed-in account, and nothing more.

Hand over the job, not the credential. Your agent pushes, deploys and calls the paid API, and never holds the key.
Tell a key where it may be used and the agent never receives it at all. Leave that blank and the value still stays out of the prompt, the command line and the transcript, but the program you ran can read it, so treat that one as a seatbelt rather than a guarantee.
Standing, or Touch ID every time. A standing secret can be used freely while it is granted to a Thread. A just-in-time secret asks you to approve each use.
On every machine you let in. A secret you add on one reaches the others, sealed the whole way, with nothing to send by hand. Remove a machine and what it had stops working.
Where the boundary stops, out loud. An agent in a terminal has the same filesystem access you do. It can read a .env you left in the project, and it only stays off your working branch if you put it on a worktree. Forkbench governs what Forkbench holds, not your machine. Move the key into Vault and that particular question goes away.

The mechanism, and every limit on it, is written up on the security page.

Talk

Talk is Forkbench in a browser. Check a Thread from your phone, read the backlog, and answer a blocked agent without going back to the desk. Free.

It attaches, it never starts. A message you send lands in a conversation already open on your machine and brings it forward. Nothing runs off-screen, so remote work is always something you can see.
Whatever agent is in the pane. It is not tied to one vendor.
It only shows what you shared. Anything you have not shared stays on your machine.
Be exact about this one. The conversation passes through us in order to reach the browser, which your notes and your keys never do. Raw tool output and scrollback stay on the machine.

Watching the work

While an agent works, your job is watching. Most of the window exists for that.

The git panel follows the tab you are focused on, so you watch the diff land instead of asking what it did. Stage, diff and commit are right there when you want them, without typing git or opening a second app.
One click puts a session on its own git worktree, so two agents never edit the same files.
The bar under the terminal lists every folder you have work running in. One click and you are in it, with the tab and the panel following you there.
The sidebar shows which Threads are busy and tells you when an agent finished or is waiting on you, so a question does not sit unanswered in a tab you are not looking at.

Work while you are away

Put a prompt on a countdown. Write the next prompt now, hand it to a pane with a countdown on it, and it runs at the time you chose. The usual reason is a rate limit that comes back in the small hours, but any prompt or command can go on one.
Two deliberate limits. Forkbench does not read your remaining quota, so the time is yours to pick. And if the machine slept past the deadline, it holds and asks first rather than firing a stale command at a session that moved on.
Sleep Control keeps the machine awake with the lid shut, so a long run finishes overnight and stays reachable while it runs.

Connect your agents

Forkbench runs any agent you can start in a terminal, with nothing configured. Connecting one goes a step further: it lets that agent read the Thread's board, claim and complete work, read the notes you granted, and run a command with a key it never sees.

Claude Code, Codex, Cursor and Antigravity CLI connect from Settings, then Integrations, in one click each. Every other agent reaches the same notes, board and keys through the fb command instead.
Anything else still works as a terminal, and can reach the same board through the command line below.

Connecting your agents covers what each one gets, the two optional helpers, and how to turn it all back off. For the protocols underneath, the blog explains ACP, MCP and LSP.

The command line

Two commands, and they do different jobs.

forkbench . opens the current directory in Forkbench from any terminal. Install it from Settings.
fb exists inside every Forkbench tab and drives the Thread that tab belongs to: the backlog, the objective, the notes, and running a command with a Vault key. It is there for you and for an agent that would rather type a command than call a tool.

The fb command line is the full reference.

Automation and APIs

There is no public HTTP API today. There are two supported ways in, and both are scoped to the Thread the terminal belongs to: the tools an agent gets when you connect it, and the fb command line. Move the tab to another Thread and the same commands address that board instead.

Everything the desktop app sends to our servers is account, billing and sync. What that covers, and what it cannot contain, is on Security and Privacy. Building something that needs more than the two surfaces above? Tell us what you are building at [email protected].

Troubleshooting

The desktop app still says "not signed in" after I signed in

The sign-in link expires after a few minutes. Click Sign in again and finish in the browser tab it opens. If it still fails, sign the machine out fully from Settings and sign in once more.

My agent cannot see the board or the notes I granted

Connect it from Settings, then Integrations, and start a fresh agent session afterwards. An agent picks the connection up when it starts, so one that was already running will not see it.

fb says this terminal is not in a Thread

fb only works in a tab inside Forkbench, which is what tells it which board to address. In any other terminal there is nothing for it to reach, and it says so rather than guessing.

A task went back to the pool on its own

That is the lease working. An agent that stopped, crashed, or had its pane closed loses the claim so the work is not stranded behind it. The task keeps its progress notes and its blocker, so whoever picks it up next starts from where it stopped, not from nothing.

Signed in on the web but the nav still says "Sign in"

A stale tab. Refresh the page: the nav reads your session on every render, so a hard reload always recovers.

The "Manage subscription" button errors

The provider's portal session is short-lived, so if you opened it once and came back, click the button again. Still failing? Email [email protected] with your account email and we will send a direct portal link.

FAQ

Does Forkbench send my code anywhere?

No. Your repositories, terminal scrollback and shell history stay on your machine. Your Notebooks and Vault sync sealed under keys we do not hold. The one exception is a conversation you open in Talk, which is relayed as readable text while it is live, because showing it in a browser is the point. See Privacy for the full picture.

Which agents does it work with?

Any agent you run in a terminal, including Claude Code, Codex, Gemini CLI, Aider and your own scripts. Forkbench sits underneath as the terminal, so it does not replace your agents or their subscriptions. Running two different vendors side by side on one board is the normal case, not a workaround.

What happens if I cancel a paid plan?

It runs to the end of the period you already paid for, then stops renewing. Nothing is deleted and nothing stops mid-run: what ends is what the plan added. On Pro that is the reach beyond one machine; on Team it is also the organisation tier: enrolment, the whole-team access log and its export, and Workspace sign-in. Everybody keeps the whole of the Free plan, exactly as before.

How many machines can I use?

Free runs on one machine at a time; signing in on another asks which to keep, and a machine beyond the limit is refused until you choose at Account, then Devices. Pro covers up to 10 of your own machines, a fair-use ceiling that is enough for any one person and is there to stop one account covering a whole team rather than to meter anybody. Notebooks storage and the Talk relay are likewise generous, with light limits only against automated abuse. See Terms.

Is there a team or enterprise plan?

Team is on the way, and it is the only thing Forkbench sells. It used to be a billing arrangement that conferred no extra access; since September 2026 it is a different product: machines enrolled into an organisation their users cannot leave, the rules set on the server, one access log across the whole team, that log as a CSV for an auditor, and Google Workspace sign-in. Minimum 3 seats. Paying for somebody’s seat still never gives you a view of their work, their notes or their keys: you see which credential was used on which job, and nothing else. Want it sooner? Email [email protected] with your seat count.

Can I get a refund?

Email [email protected] within 14 days of the charge and we refund it, no questions. After 14 days we look at it case by case.

Is there a Windows or Linux version?

Ships on Mac today. Windows and Linux are in development. We are not naming a date. Leave an email on /download and we will tell you the day either one ships.

Still stuck?

Contact lists every email route. We answer.