Open source · Cloud beta live

All your coding agents. One workspace.

Run agents side by side, carry context between them, and keep every task isolated in its own git worktree.

Free in beta · no token markup

What should we build in forkzero?

Continue Threads3

How Zuse works

One repo. Many agents. No lost context.

Zuse keeps every agent session connected to the code, branch, and review state it belongs to.

  1. 01

    Bring the agents you already use

    Connect your existing coding-agent subscriptions and choose the right provider for each session.

  2. 02

    Run work in parallel

    Give every task its own chat, branch, and git worktree so multiple attempts never overwrite each other.

  3. 03

    Carry context, then review

    Continue with another agent using the plan, transcript, or files it needs, then inspect the diff before anything ships.

Bring the subscriptions you already pay for. Zuse orchestrates them — no token markup.

Claude Code
Codex
Cursor
Grok
Gemini
OpenCode
Kiro

Agent handoff

Continue the work with another agent

Fork a session or start a new provider with the plan, transcript, and files it needs. You choose what moves forward.

Plan with one model, continue with another

Start another provider session for implementation and attach the plan, transcript, or files it needs.

Planning session

Claude Code

Plan complete

Implementation session

Codex

Ready to start

Handoff context

Plan
Diff
Tests

Fork when a provider hits its limit

Fork the session to another provider and carry forward a copied transcript or explicit handoff context.

Continue this work

Choose a provider and context

New Codex session

Fork from here

Transcript

Copied

Files

Select to attach

Pick a model per step

Choose which agent handles planning, coding, and review — per task, not per project.

Attach the right context

Add a plan, transcript, diff, or focused files when starting the next session.

You stay in control

Choose the provider and model for each session, then decide what context to carry forward.

Parallel work without
branch chaos.

Every task gets an isolated branch and working tree. Run several agents at once without mixing their changes together.

agent/checkout-recovery

Running
Claude Code12 files · 16 tests

agent/session-race

In review
CodexPR #814 · 2 comments

agent/sidebar-cache

Cleaned
Claude CodeMerged · history kept

Every run stays isolated

Claude → Codex handoff

same worktree · same branch

Plan attached

Transcript attached

Diff · 12 files

Tests · 16 passing

Codex reviewing

Hand off the complete context

1.8 GB reclaimed

Branch preserved

Commits + run history kept

Worktree removed

Reclaim disk without losing work

One worktree

Multiple tabs, shared context

Implementation, review, and checks stay side by side on the same branch and working tree.

Claude Code · implementation

Build the change in one tab while every file lands in the shared worktree.

checkout-recovery

agent/checkout-recovery

Shared worktree
Claude Code

Implementation

Running
Terminal

Focused tests

16 passed
Codex

Diff review

Reviewing
Codex · diff review

Review the same branch and transcript in a second tab without copying context.

Shared context
Review the current diff and verify checkout recovery without editing.
Worktree tabs3
Codex · review
Connected
Claude Code · build
Connected
Checks · terminal

Keep typecheck, focused tests, and terminal output beside both agent sessions.

Claude · implementation
running
agent/checkout-recovery
Codex · diff review
2 findings
agent/checkout-recovery
Terminal · focused tests
16 passed
agent/checkout-recovery
Changes · 12 files
+184 −32
agent/checkout-recovery
Codex · review resolved
2 fixes
agent/checkout-recovery
PR #814 · ready
checks passed
agent/checkout-recovery
Claude · implementation
running
agent/checkout-recovery
Codex · diff review
2 findings
agent/checkout-recovery
Terminal · focused tests
16 passed
agent/checkout-recovery
Changes · 12 files
+184 −32
agent/checkout-recovery
Codex · review resolved
2 fixes
agent/checkout-recovery
PR #814 · ready
checks passed
agent/checkout-recovery
Claude · implementation
running
agent/checkout-recovery
Codex · diff review
2 findings
agent/checkout-recovery
Terminal · focused tests
16 passed
agent/checkout-recovery
Changes · 12 files
+184 −32
agent/checkout-recovery
Codex · review resolved
2 fixes
agent/checkout-recovery
PR #814 · ready
checks passed
agent/checkout-recovery

Review

From changed files to a verified pull request

Inspect the complete branch, commit deliberately, push when it is ready, and send failed checks back to the active agent.

Review every changed file

See the branch diff, changed files, and line totals before anything leaves your machine.

Branch review

Branch

agent/checkout-recovery

4 COMMITS

Changed files

9 modified · 2 added · 1 deleted

12 FILES

Branch diff

+182 additions · −47 deletions

DIFF

Uncommitted work

3 files ready to review

LOCAL

Review range ready

Compared with origin/main

READY

Inline diff review before push

Review additions, deletions, files, and agent findings without leaving Zuse.

+ guard retry
- stale state
test.ts
+ regression
16 passed
review
2 comments
resolved

Codex review: Retry only after the persisted checkout state is restored.

Commit selected files & push

Choose exactly which files enter the commit, write the message, and push the branch when it is ready.

agent/checkout-recovery
3 selected
auth/session.ts+18 −4
auth/recovery.ts+31 −0
auth.test.ts+22 −2
fix: recover expired checkout sessions
Commit 3 files
Push

Send failing checks to the agent

Collect failed GitHub Actions logs and attach them to the agent thread so it can diagnose and fix the branch.

checkout-e2e

GitHub Actions · failed

exit 1

FAIL tests/auth-recovery.spec.ts

Expected redirect to /dashboard

Received /login?expired=true

36 log lines collected

Agent thread

agent/fix-auth

Failed check attached

failing-checks-0821.txt · 36 lines

Diagnosing session redirect…

Browser verification, built in

Let an agent drive a real browser and verify the flow inside Zuse

Import browser sessions

Copy valid cookies from a local browser profile into Zuse's built-in browser. Passwords are never imported.

Local profiles

Chrome · Profile 1
Safari

Zuse browser

Session ready

3 signed-in sites

12 valid cookies copied

Cookies only

Passwords stay in your browser

Local transfer

Never written into agent chat

Drive the whole flow

Navigate, fill forms, click controls, and inspect the resulting page state.

Open /checkout

navigation

Enter card

input

Place order

click

Receipt visible

assert

Watch browser actions live

See the page as the agent works and keep screenshots and results in the thread.

Claude CodeStep 3 failed: checkout button selector changed.
CodexUpdated the selector from the trace. Retrying now.
Claude Code4/4 steps passed · trace saved · 1.8s
checkout.local/receipt
receipt visible
trace captured

Describe what to verify

Give the agent the flow and expected result; it performs the browser actions for you.

“Sign in, finish checkout, verify the receipt.”

checkout.spec.ts · generated

esc
F1
F2
F3
F4
F5
F6
F7
F8
F9
F10
F11
F12
~
1
2
3
4
5
6
7
8
9
0
-
=
delete
tab
Q
W
E
R
T
Y
U
I
O
P
[
]
\
caps
A
S
D
F
G
H
J
K
L
;
'
return
shift
Z
X
C
V
B
N
M
,
.
/
shift
fn
ctrl
opt
cmd
cmd
opt

Signed-in sessions

Copy valid cookies from a local browser profile. Passwords are never imported.

A real, headless browser

Tests drive an actual browser — clicks, typing, navigation, and assertions.

Inspect and retry

The agent can inspect the current page state, adjust the implementation, and try the flow again.

Keep agent work moving anywhere

Run agents from your desktop today, keep them working in persistent cloud environments, and follow them from mobile soon.

Connected

Agents in your pocket

Coming soon

Follow runs and approve decisions from your phone.

Zuse desktop workspace
Agent finished

Full control at your desk

Available now

Run agents, inspect changes, and manage worktrees in Zuse Desktop.

Agents that keep running

Live beta

Run isolated cloud workspaces even after your computer goes offline.

Cloud beta

Interested in a hosted workspace?

Register your interest as we open beta capacity to more developers.

Questions devs ask first

More questions? See the project on GitHub.

Zuse puts your coding agents, repositories, terminals, files, and diffs in one workspace. You can run several tasks in parallel, keep each one isolated in its own git worktree, and carry selected context from one agent session to another.