v0.37Shipping almost every hour

Every prompt splits the universe.

Forkspace is an open source editor for Claude Code. Fork any step into a parallel timeline, code and all. Run them side by side. Keep the one that works.

Click anywhere to fork a timeline
1 timelines running
localhost:4747 · canvas
Forkspace canvas: Claude Code agent steps branching into a tree Forkspace details panel: a side question about a selected phrase, answered under it Forkspace Chat view: a thread with its branches listed between steps

Every step an agent took, as a map. Branches included.

Editors were built for one timeline. Agents gave you *infinite* ones. So we built the place to *direct* them.

The shift

What changes.

Tabs and terminals everywhere→One canvas of every agent
Undo and hope→Branch from any step, code included
Read the diff at the end→Watch every change land
Nod at code you don't get→Actually get it
Paste a line into another chat→Select it, ask, move on
Stuck at your desk→Approve from your phone
Try it

Go on. Fork something.

Every card is a step an agent took. Hit Branch on any of them and try another idea from there. No real code was harmed.

1 step · 1 branch
Direct

Many agents. One map.

Branch from any step. The code branches too, each in its own git worktree. Bad idea? It stays on its branch.

Forkspace canvas: Claude Code agent steps branching into a tree
Review

Watch the code change.

Every edit in red and green, the moment it lands. No giant diff at the end.

Forkspace code view: file tree and a live diff of the agent's changes
Ask

Ask about any line.

Select a phrase in any answer and ask what it is. The reply lands right under it, and the thread stays clean.

Forkspace details panel: a side question answered under the selected text
Canvas view
Code view
A side question
DirectReviewAsk
Shipped lately

It gets better while you sleep.

One click updates, with release notes a human can read. Here's some of what landed this week. Go on, poke them.

58
releases in 4 days
0.29

Diffs you can read.

Every edit an agent makes, in red and green, line by line. Unchanged code folds away.

src/math.ts+3−1
export function power(base: number, exp: number) {
− return Math.pow(base, exp);
+ let result = 1;
+ for (let i = 0; i < Math.abs(exp); i++) result *= base;
+ return exp < 0 ? 1 / result : result;
}
0.30

> terminal mode

The whole app as a shell. Phosphor green, square corners, blinking cursors. This site has it too.

$ forkspace --mode terminal
ok. welcome home.
$
⌥⌘T
0.29

Safety pauses that explain.

When a rule stops a risky command, you see what it does and what could go wrong. Then pick.

◆ Paused by a safety rule
rm -rf dist && npm run build
Does
Deletes the build folder, then builds it fresh.
Risk
Low. Only build output goes.
0.37

Read, then move on.

J and K step through a thread. B branches from the card you're on. Your hands stay on the keys.

J  Next step
K  Previous step
B  Branch from here
0.37

Ask about any line.

Select part of an answer, tap Ask. The reply shows up right under it. One click turns it into a branch.

It now uses exponentiation by squaring to stay fast.

Squares half the answer instead of multiplying a thousand times. 1000 steps become about 10.
0.37

Branches land where you look.

A new branch sits beside its sibling, right under the card it came from. Nothing jumps across the board.

Concepts

Not a spectator. A better engineer.

While an agent wrote a small calculator, Forkspace explained the ideas behind its code. These are the real notes.

The function calls itself on a simpler version of the same problem. Here a negative exponent becomes a positive one, and the positive case does the real work.

if (exp < 0) return 1 / power(base, -exp);
let result = 1;
for (let i = 0; i < exp; i++) result *= base;
return result;
From the request Make power handle negative exponents.

Save answers you have already worked out. When the same inputs come back, return the saved answer and skip the work. The trade off: it never forgets, so memory grows.

const key = `${base}^${exp}`;
const cached = powerCache.get(key);
if (cached !== undefined) return cached;
From the request Make repeated calls instant.

Start at 1 and multiply by the base once per step. A negative exponent means divide instead, so the result is flipped: 1 divided by it.

let result = 1;
for (let i = 0; i < Math.abs(exp); i++) result *= base;
return exp < 0 ? 1 / result : result;
From the request Add power(base, exp), no Math.pow.
Anywhere

Step away. Stay in orbit.

Your Mac does the work. Your phone reaches it over your own private network, paired with a one time code. Tap Allow. Keep walking.

Agent needs youRun npm test in calc? Tap to allow.
Behind the scenes

No magic. Here's what runs.

The agents

The same Claude Code you already use. Your settings come along.

The concepts

A small, fast Claude model explains what the agent did. It can't change anything.

Your key

Runs on your own Anthropic API key.

Your code

Stays on your computer.

Forkspace

Free and open source. Read every line.

Questions

Asked often.

What is Forkspace?

A free, open source editor for Claude Code agents. Every prompt becomes a step on a canvas. Run many agents side by side, branch from any step, and review each change as a live diff.

How is it different from the Claude Code extension or CLI?

Same agent underneath, built on the Claude Agent SDK. Forkspace adds the map: many agents at once, branches you can see, a code view per branch, approvals from your phone, and concepts explained as agents work. Your existing Claude Code sessions come in with one click.

Can I branch a Claude Code conversation?

Yes, from any step. The agent remembers everything up to that step and nothing after. In a git repo the code branches too: each branch works in its own git worktree, so branches never overwrite each other.

Can I run several Claude Code agents at the same time?

Yes. Each thread or branch is its own agent. Anything waiting for your approval glows on the canvas and shows up under Agents.

Can I use it from my phone?

Yes. Agents run on your computer and your phone is the remote. Pair over Tailscale with a 6 digit code, get a ping when an agent needs you, and tap Allow or Deny.

How do updates work?

Settings, then Update. One click pulls the new version, rebuilds and restarts it, with release notes in plain words. It ships often.

What do I need, and what does it cost?

Node 20 or newer, git, and an Anthropic API key. Forkspace itself is free under the MIT license. It runs on your machine and your code stays there.

Can I sign in with my Claude subscription?

Forkspace runs on an Anthropic API key, not your Claude.ai plan. Anthropic asks apps built on Claude Code to work that way, and it keeps your usage and costs clear.

Will agents replace me?

Not while you're the one with taste. Forkspace keeps you directing, reviewing and learning. The agents do the typing.

Install

Running in a minute.

Node, git and an Anthropic API key. Then turn on Keep running in the background and forget the terminal.

$ 

Stop typing.
Start directing.

Designed and built by nikhils4