Workbench

Get your agents under control

Give your AI agent a bench to work on.

Research, Plan, Execute, Test, Review, Ship. Agents write the code. Workbench makes sure the work gets done properly, on your machine, with you in control.

DownloadTalk to us
workbench/workbench
[EXECUTE] editing agent-providers.mjs
Stop

Changed files

agent-providers.mjs+42 −6
config-renderer.mjs+18 −2
SessionPage.tsx+64 −21
diff.ts+9 −0
schema.sql+4 −0

server/agent-providers.mjs

112 export function buildAgentSpawn(session, provider) {
113 const env = augmentedPath(process.env);
114− const model = provider.defaultModel;
114+ const model = session.model ?? provider.defaultModel;
115+ // model changes apply on the next turn, not mid-run
116 const child = spawn(provider.bin, args, { env });
117+ runningProcess.set(session.id, child);
118 return { child, model };
119 }

A workflow the agent cannot skip

Every session moves through Research, Plan, Execute, Test, Review, and Ship, so the agent investigates and gets your sign-off instead of dumping files into chat.

Control the agent, not just the prompt

Rules, skills, domain, and clarifications keep the agent on the outcome you defined. Loop mode goes deep on one goal; Mesh mode fans out across lenses. You stay in control either way.

Understand what changed before you ship

Review is built for agent-sized diffs: walk the change, ask why it happened, visualize the impact, then comment and approve with context, not just +143000/−67000.

Work bench

From understanding to shipping, with you in the loop.

Start from a repo and a goal. Workbench runs a structured workflow so the agent researches, plans, implements, and hands you a clear path to test and ship, not a wall of chat.

workbench/workbench
[EXECUTE] editing agent-providers.mjs
Stop

Changed files

agent-providers.mjs+42 −6
config-renderer.mjs+18 −2
SessionPage.tsx+64 −21
diff.ts+9 −0
schema.sql+4 −0

server/agent-providers.mjs

112 export function buildAgentSpawn(session, provider) {
113 const env = augmentedPath(process.env);
114− const model = provider.defaultModel;
114+ const model = session.model ?? provider.defaultModel;
115+ // model changes apply on the next turn, not mid-run
116 const child = spawn(provider.bin, args, { env });
117+ runningProcess.set(session.id, child);
118 return { child, model };
119 }

The workflow, enforced

Research, Plan, Execute, Test, Review, Ship. Stages are visible; the agent does not skip straight to dumping code.

Loop mode: delegated work

Set a goal, flip Loop on, then send. Enabling Loop alone does not start a run. Answer clarifications, then go test. Send again after Go test if something fails and Loop resumes.

Learn more

Mesh mode: look, then decide

Mesh runs analysis diamonds Research, Code review, Security audit that write findings, not silent fixes. Execute or Loop is where code changes. Parallel saves time, not tokens (~3–5× a single chat on a standard run).

Learn more

Stay on one topic

Each session keeps a clear domain (chip + notes in the sidebar). If the agent drifts, Workbench pauses so you can start a focused new session or allow the detour.

Project memory that sticks

Knowledge is your notes. Brain is the map. Each session gets only what matters for this job, so the agent stays oriented without a wall of paste.

Learn more

Know when to return

When Workbench is in the background, desktop notifications ping you for clarifications, Go test, failures, or a visualizer that is ready. Click to jump back in.

See what changed, and why

Canvas with diffs and a plain-language "why this changed" panel built from the agent's own steps.

Steer mid-run

Stop a runaway agent, switch models, Break Loop to chat freely, or reply from the canvas with file context included automatically.

Ship from the sidebar

Accept the plan in the Spec panel, pass QA when it runs, then stage, commit, push, and open a PR. Ship blocks commit until the plan is approved.

Crash-safe

Interrupted sessions come back in History so the agent can continue from the last completed step.

Context usage

See exactly what is filling the context window.

Every turn, Workbench shows window fill from the agent CLI and cumulative in/out across the session. The fill bar is the latest turn; Mesh runs several turns, so watch reported usage and turn count for cost. Category chips are a size estimate of what is heavy, not a bill.

Context usage~14.4K of 200K tokens
Instructions
436
Tools
534
Rules
3.1K
Skills
858
Helpers
1.3K
Subagents
536
Task notes
3.3K
Conversation
4.3K

Estimated from what Workbench sends. Rules, skills, and task notes usually take the biggest share.

Pipelines

From an empty folder to a real start.

Two starters for greenfield work. One ships a marketing site you can deploy. The other builds the full project plan, then the work begins.

empty folder · new workspaceNew project

Website builder

Describe the site and get a complete marketing build: pages, structure, and something ready to put online.

Project docs

Kick off a full project plan: discovery, sprints, user stories, and the docs your team needs before feature work.

Describe the work

A landing site for my product, or a full project plan with sprints and stories…

Your description steers the whole run

Ship a site, fast

Website builder turns a blank folder into a structured marketing site your agent can finish and you can deploy.

Plan the whole project

Project docs starts with discovery and carries through sprints and user stories so you begin with a clear backlog.

You describe it once

Say what you want up front. Workbench keeps the agent on that plan while it builds with you.

Review bench

Review like an engineer joining the project.

Agents can produce thousands of lines in minutes. Workbench helps you understand the change: what moved, why, and what to test. Then comment, approve, or walk the stack before you merge.

#128 · Handle missing agent CLI without throwingOpen
server/
agent-providers.mjs+42
config-renderer.mjs+18
client/
SessionPage.tsx+64
86const providers = await detectProviders();
87if (!providers.length) throw new Error("none");
87if (!providers.length) {
88 return { ok: false, reason: "no-agent-cli" };
89}
90return { ok: true, providers };

Returning a reason here lets the welcome wizard show install instructions instead of a crash toast.

Comment on lines 87–89posts to GitHub

Understand, then approve

Description, diffs, and findings framed for comprehension, not only a file list.

Ask why this changed

Visual walkthrough with progress, code excerpts, and agent reasoning you can interrogate. Confirm before critical comments land on the PR.

Diffs that read properly

Side-by-side or full-file views with a clear list of what changed.

Comment and submit

Inline notes, jump to threads, then approve, request changes, or leave an overall comment.

Stacked PRs, one review

When related pull requests stack on each other, review or walk through the whole stack as one change. Comments land on the PR that owns each line; you can approve the stack in one go.

Findings in full

Warnings and notes show up as complete write-ups, not truncated one-liners.

Ops

Keep the whole project running while you work.

Workbench finds the services in your workspace and puts start, stop, status, and rebuild within reach, plus your own named commands, without leaving the session.

project servicesRebuild all

database

UpDownStatus

cache

UpDownStatus

api

UpDownStatus

web

UpDownStatus

worker

UpDownStatus

scheduler

UpDownStatus

auth

UpDownStatus

jobs

UpDownStatus

Environment · secrets masked

DATABASE_URL••••••••••••••••••••
SECRET_KEY••••••••••••••••
APP_PORT3000
Pre-ship checksall clear

Service controls

Bring each service up or down, check status, or rebuild, including rebuild-all when you need a clean slate.

Your own named runs

Save the commands you actually use for a repo, or let Workbench suggest them from the project.

Secrets stay masked

Edit environment values with secrets hidden by default, and tidy ignore rules in a click.

Checks before you ship

Run your repo's pre-push checks from the same panel and read the output in the ops log.

Agent engines

Your agents. One workflow.

Claude Code, Cursor, Codex, and OpenCode run as engines inside Workbench. Rules and skills apply the same way. Workbench is the control plane, not a replacement IDE.

Cursor AgentRules, skills, and tools, delivered automatically
Claude CodeRules and skills, delivered automatically
Codex CLIRules and skills, delivered automatically
OpenCodeRules and skills, delivered automatically

Bundled helpers

Company rules

Coding standards, architecture, security, and AI policies, applied in every session

Domain expert

Context, constraints, and industry notes so the agent understands your problem space

Spec writer

Turns a feature idea into a clear technical plan before code starts moving

QA check

Compares the work against the plan and surfaces issues while you can still fix them

The rest of the bench

Everything else you would otherwise keep in tabs.

Knowledge & Brain

A living set of notes and a map for your project. Sessions get only what matters for this job not a paste of everything you ever wrote.

Plan panel and Ship gate

The Spec panel captures the technical plan from the MCP pipeline. Accept plan unlocks commit in Ship; QA results show beside it when validation runs.

Toast feedback

Save and action outcomes show as bottom-right toasts, so status lines do not clutter the session or settings panels.

Session and ops logs

A scroll-preserving log viewer keeps your place while agent output and ops runs stream by.

MCP vault paths

Point helpers at your own knowledge folders in Settings, or use the profile vault Knowledge provisions for org and repo overlays.

Ship panel and PR writer

Stage what you want, write the commit, push the branch, then let the agent draft the PR title and body before you open it.

History and recovery

Browse past sessions and reviews with status and timing. Resume interrupted work, or clear what you no longer need.

Your usage, at a glance

Settings > You shows tokens, sessions, visualizer runs, and review activity for the active profile, with clear charts and tiles, all from data on your machine.

Desktop notifications

Step away while the agent works. Get pinged when it needs a clarification, hits Go test, fails, or a visualizer finishes, only when the window is in the background.

Rules and skills that stick

Keep shared defaults, then add your own rules and skills per profile. Skills and rules load on demand so sessions stay lean.

Your knowledge, your folders

Edit markdown in Knowledge anytime the map is wrong. Remotes Pull and Push keep org and repo layers in sync when you link them.

Profiles and accounts

Separate workspaces per person on a shared machine, each with the GitHub accounts they need.

Open in your editor

Jump into Cursor, VS Code, or another editor you already use when Workbench detects it.

Clarifications as decisions

When the agent needs a call from you, it shows up as a clear card with options, not a question buried in a wall of text.

Task notes that follow the session

The right task notes stay bound to the right session, even when several runs share a workspace.

On your machine

Everything stays on your machine.

Create a profile on first run and start working. There is no Workbench account and no cloud sync. Agent calls go only to the provider you chose, under their terms.

Accounts required
None
Data storage
On your machine
Telemetry
Off by default
GitHub linking
Optional

Talk to us

Want help getting set up?

Downloads are live on the Download page. Book a short call if you want onboarding help while the first cuts stabilise.

You get

  • Builds for Linux, macOS, and Windows
  • A direct line for bugs, crashes, and feature requests
  • Influence over the roadmap while it is still soft

We ask

  • You already use an AI coding agent day to day
  • You are comfortable with git and pull requests
  • You will tell us when something is broken or confusing
Talk to us

On the roadmap

More agents
Support for more coding agents and smoother runs across machines.
Team workflows
Share rule packs and move profiles between machines more easily.
Richer review
Review templates, batch PR review, and tighter checks before you merge.
Cross-platform polish
Smoother installs and updates on every platform.
Mesh library & budgets
Browse saved Meshes from Repos, push findings into Review, and set turn or token budgets beyond the parallel worker cap.
Semantic knowledge
Embeddings and RAG over org and repo vaults so helpers return the right slice, not keyword matches only.

Questions, answered.

Ship with your agent, not around it.

Get your agents under control. Two minutes from install to your first structured session, all of it on your own machine.

DownloadTalk to usWhat's in 0.4.0