A hackable dev workspace for agentic coding

Build the workspace
your terminal never could.

The things a terminal never could: parallel worktrees, every plan and diff reviewed (solo or with your team), the repeat work automated — all shaped like your dotfiles, with workflows and config committed in the repo. Ship from one place, on Claude, Codex, and every account you own.

curl -fsSL https://zurge.dev/install.sh | bash

Local-first. No new account. Uses your existing Claude login. macOS (Apple Silicon) beta.

zurge reviewing a plan
Plan Diff Browser Response

The category

Not another agent. The workspace around it.

Your coding agent is still the engine. Zurge is where that work actually happens — a real workspace in place of a scrollback buffer: many streams at once, every plan and diff reviewed, then shipped. The faster agents code, the more that workspace matters.

✦

Claude · Codex · any CLI

The implementation layer

  • Plan the approach
  • Edit files
  • Run commands
  • Implement the change
◉

Zurge

The workspace layer

  • Parallel work on isolated worktrees
  • Plans and diffs as reviewable cards
  • Review solo or with your team
  • Workflows + the Genie automate the rest
⑂

GitHub

The ship layer

  • Open the pull request
  • Code review and CI
  • Merge to main
  • Shipped history
curl -fsSL https://zurge.dev/install.sh | bash

Free, local-first, and it uses the Claude login you already have.

The workspace

Everything your terminal couldn't give you.

Agent work is never just a prompt. It's a session, a branch, a diff, a terminal, a preview — times however many you're running at once. Zurge gives all of it a home, not a scrollback buffer.

⚡

Workflows & schedules

Turn any repeatable job into a saved workflow — Slack triage, a release, a bug sweep. Run it with one command, or on a schedule so it just happens, hands-off, while you're away.

New ✦

The Genie

One agent that runs the fleet. It spins up worktrees, investigates bugs, and runs your scheduled workflows while you're away — then waits with the fix already written, gating only the final send on your go-ahead.

⑂

Automatic worktrees

Every task runs in its own isolated git worktree, created and cleaned up for you. Run many in parallel without branches colliding.

◈

Any model, any account

Claude, Codex, or any CLI, across every account you own. Set an account per repo, keep every chat and plan in Zurge, switch engines mid-task, and auto-cycle to your next account the moment one hits its limit.

▦

Grid mode

Watch several worktrees side by side on one screen, all running at once, like a madman.

◆

Generate multiple plans, pick the best

Ask Claude for several plans from different angles, compare them side by side, and send the one you like best to build.

⧉

Remote control

Watch and steer every worktree from your phone over a secure relay. Answer prompts and send follow-ups while you are away from the desk.

»

Race mode

Run one task across several agents, keep the best result.

◌

Built-in voice

Local, private speech to text. No cloud, no API key.

⇄

Drag-and-drop migration

Import your existing terminal setup and bring your Claude Code sessions over in seconds.

◐

Fully customizable

Themes, keybindings, and layout. Make it yours, raw terminal one tab away.

◍

Built-in browser

Annotate a live web page and send it straight back to Claude. Bring your logins in.

The problem

Your terminal wasn't built for this.

One agent at a time, in a scrollback you can't really review. The plan scrolls away, the diff is buried in tool noise, feedback is copy-paste — so you approve work you never actually read, and unwind it two weeks later.

Plans buried in chat
Diffs lost in tool noise
Feedback is copy-paste
You review too late
Then you unwind it

01 Plan review

Catch the wrong idea before it becomes code.

Most agent mistakes are decided before a file changes: wrong scope, wrong assumption, wrong approach. Zurge makes the plan a card you can push back on first.

  • ›Comment on a specific plan line.
  • ›Ask Claude why it chose an approach.
  • ›Request a smaller scope.
  • ›Approve only when the strategy is right.
  • ›Keep the approved plan attached to the implementation.

Catch the wrong approach before it becomes a twelve-file diff.

◆Planrate-limit-loginpending review
1Add a token-bucket limiter in lib/ratelimit.
2Wire it into the auth middleware for every route.
you · ask claudeWhy every route? Scope this to the login endpoint only.
3Return 429 with a Retry-After header.
4Add tests for the limit and the reset window.

02 Diff review

Every edit becomes a diff you'd actually review.

Claude's edits shouldn't live in a wall of tool output. Zurge turns them into clean red-and-green diff cards you read like a pull request.

  • ›Inline diffs for Edit, Write, and MultiEdit.
  • ›Highlight a hunk and comment on it, like a PR review.
  • ›Send a comment back as a change request, applied in the same worktree.
  • ›Ask Claude why it made a change, answered inline.
  • ›Hide low-signal tool noise.

Comment on the exact lines. Get the change or the answer back, without leaving the diff.

✎MultiEditsrc/lib/ratelimit.ts
export function allow(key: string) {- return true // TODO+ const b = buckets.get(key) ?? fill()+ if (b.tokens < 1) return false+ b.tokens -= 1; return true }
you · comment on line 4This silently drops requests. Return a 429 with Retry-After instead, and add a test.
↩ Send as change request
✎Editsrc/auth/login.ts
+ if (!allow(ip)) return res.status(429)
you · ask claudeWhy rate-limit by IP and not by user id?
claude · answerLogin happens before auth, so there is no user id yet. IP is the only stable key at this point; we switch to user id on authenticated routes.

03 Feedback loop

Your comment becomes the agent's next instruction.

Mark up the plan or diff, then send it straight back to Claude in the same worktree as instructions it can act on. No copy-paste, no lost context.

Comment once. Send it back clearly.

↩Send feedback to Claude

Review feedback

  1. Do not change webhook retry behavior.
  2. Revert the hunk in checkout/session.ts.
  3. Add a test for 429 responses.
  4. Explain why this helper belongs in lib/payments.
↩ Send to Claude

04 Receipts & recaps

Know exactly what Claude did, even after you stepped away.

When a task finishes, Zurge writes a receipt: the plan, the real diff, the commands run, the tests skipped, the risky bits. Step away and a "where we left off" recap catches you up in seconds.

Less "looks good to me." More "I know what changed, and where I left off."

▣Implementation receiptneeds changes
Added a token-bucket limiter to the login route — returns 429 with a Retry-After header.
▸ratelimit.ts+64−3
▸login.ts+18−6
▸checkout/session.ts⚠ risky+4−9
npm run build ✓429 unit tests — not run
⏱Where we left offrate-limit-login
  • Built a token-bucket rate limiter and wired it into the login route, returning 429 with a Retry-After header.
  • Build is green, but the unit tests for the 429 path aren't written yet.
  • Heads-up: this also touched the retry policy in checkout/session.ts.
  • Next: add the 429 tests, then open a PR.

05 Review together

Loop in your team without leaving the flow.

Review solo by default. When a change matters, publish the plan to a shareable link your teammates open, comment on, and approve — right in the browser, no new tool to learn. Their feedback reaches the agent the same way yours does.

  • ›Publish any plan to a private review link.
  • ›Teammates comment on lines and request changes.
  • ›Approval gate — build only after sign-off.
  • ›Solo-first; bring a reviewer in only when it counts.

The same review surface, shared — not a separate PR dance.

◆Shared planrate-limit-loginapproved
1Token-bucket limiter on the login route.
2Return 429 with a Retry-After header.
alex · approvedScope looks right — ship it once the 429 tests are in.

Get started

Build yours in a minute.

Point Zurge at a repo and run your next task in a real workspace instead of a scrollback. Free, local-first, and it uses the Claude login you already have.

curl -fsSL https://zurge.dev/install.sh | bash

Free for individual developers. macOS first. No credit card, no catch.

Creator note

I built Zurge for myself. Claude Code got fast enough to do real work, but reviewing that work still meant scrolling a terminal log: rubber-stamping diffs I hadn't really read, and catching problems only once they'd already hardened into a PR. I didn't want the agent to do more on its own. I wanted to see what it was doing, steer it sooner, and trust the change before it shipped.
Rajat Kaushik
Rajat Kaushik
Creator of Zurge

FAQ

Questions developers ask.

What is Zurge?

Zurge is a hackable dev workspace for agentic coding — the workspace your terminal never could be. You run parallel worktrees, review every plan and diff as a card (solo or with your team), ship, and automate the repeat work with workflows. The Genie can create worktrees, fix bugs, and run your scheduled workflows while you're away — then wait for your go-ahead on the final send.

Does Zurge replace my coding agent?

No. Claude, Codex, or whatever CLI you use is still the engine that writes the code. Zurge is the cockpit above them: launch a fleet, review the plans and diffs, send feedback straight back, and approve before anything ships.

Which agents does Zurge work with?

Claude Code and Codex run in the app today, plus any CLI agent you configure — across every account you own, with each chat and plan kept in Zurge so you can switch engines mid-task. The Zurge MCP also plugs into any tool that speaks MCP (Cursor, Gemini, and more) for the plan-review flow.

Is my code uploaded anywhere?

No. Zurge is local-first and your code stays on your machine. The optional phone-remote and plan-share features only carry session text or the plan you choose to share, never your repository.

Do I need a new account or API key?

No. Zurge uses your existing Claude Code login. There is no Zurge account and no separate API key to manage.

How much does Zurge cost?

Zurge is free for individual developers.

Which operating systems does Zurge support?

Zurge is available for macOS first. Windows and Linux support is planned.