The command line version of a coding agent is powerful, but its interface is one screen of scrolling text. The moment you want several things moving at once, the terminal becomes the bottleneck, and that empty spot on the desk is what Claudette is trying to fill.

Anyone who has used a command line coding agent knows the feeling: you only dare give it one job at a time. Not because it cannot do more, but because the moment things run in parallel, several streams of output start competing for the same screen. You lose track of which line belongs to which task, and you cannot say with confidence which files the current round of changes actually touched. Work proceeds one task at a time, and the clock stretches out.

Claudette is an open source desktop application that positions itself as a desktop companion to Claude Code. What it does is concrete: in a single window you can dispatch several agents onto different branches to work at the same time, and see at any moment how much context each one is burning.

One workspace, one branch, one agent

The core mechanism rests on git branch worktrees. Every time you create a workspace under a repository, Claudette builds an independent worktree on a new branch and starts a dedicated session inside it.

The word that matters is independent. Each agent sees only the files in its own worktree, fully isolated from the other workspaces. So one agent can build a new feature, a second can fix a defect, a third can fill in tests, all three advancing in the same repository, each landing changes on its own branch, none overwriting the others along the way. When one finishes, you walk it through the normal merge path back to the mainline.

A session has its own lifecycle state: running, idle, stopped. To interrupt one, a press of Escape stops it, with no window to close and no process to kill.

Putting context usage on the table

The trap in running agents in parallel is not knowing how much budget each one has left. Claudette reads the usage events out of the agent's streaming output and puts a segmented context bar above every turn, breaking the figure into input, output and cache.

When a session nears its ceiling, a compression instruction is available from inside the conversation, and a marker is left on the timeline: nothing was thrown away, history was folded, and it can still be walked back through. Beyond single sessions it aggregates usage per workspace, with a heatmap, a ranking and session history. All of that stays in a local database file and passes through no cloud relay.

What changed and where it was written, in one window

Once an agent produces changes, the review step cannot be skipped. A built-in diff viewer offers side-by-side and unified layouts, and renders Markdown and Mermaid diagrams for plans and review notes. Diffs open as tabs beside the conversation, so the explanation can be read while the actual change is checked against it.

One layer down sits the editor. It embeds Monaco, the same engine behind mainstream code editors, with type-aware highlighting and language services, running entirely offline so no code has to be shipped anywhere for analysis. Combined with a real terminal per agent, split panes included and common shells supported, the daily loop of conversation, revision and command runs barely leaves the window.

One design decision earns its keep on long tasks: checkpoints and workspace forking. A session can rewind to an earlier turn, or fork a parallel copy from a checkpoint to try a different implementation route while the original stays untouched.

Opening a session on another machine

If the repository lives on a faster machine or an always-on server, remote workspaces are available. An encrypted WebSocket connection reaches the other machine and shows its repositories, agents and terminals in place inside your local interface, with no obvious difference from a local workspace.

Transport runs over TLS, and the local application pins the server's certificate fingerprint on first connection and verifies it on every connection after; if the certificate changes, you are asked to confirm again. Machines on the same local network can be discovered automatically, which spares you typing connection details by hand. For a machine with no graphical interface, a standalone server component is published that can be deployed on its own.

Open source, local first, and hands off your credentials

Claudette is released under the MIT licence with the full source public. There is no account system: it opens and works, with no sign-up step. No telemetry, analytics or crash reporting either, and the project states plainly that it operates no relay servers.

Credential handling draws a clear line. It does not authenticate against the model vendor on your behalf; it launches the official command line tool already installed and signed in on your machine, and that tool uses the credentials you configured. The agent subprocess never receives your subscription token, because Claudette actively strips inherited tokens from the subprocess environment. There is one documented exception: when you open the usage panel it reads local credentials to query account usage, so that subscription type and limits can be shown. Leave the panel closed and that code path never runs.

What it is, and what it is not

It carries no model of its own. The default route drives the official command line program you already have installed and signed in, so the work is still done by that official agent. Beyond that, the backend can be switched to a locally running model service or another API endpoint, for users who want to work their own way.

It is an independent community project with no affiliation, endorsement or sponsorship relationship with the model vendor; it simply calls the official command line tool. When running agents in parallel, the official guidance is to keep the default degree of parallelism low and treat it as something you switch on deliberately rather than a default posture. Anyone with heavy usage is pointed toward API key authentication as the compliant route.

It builds natively for macOS, Linux and Windows. The release line advances steadily and offers both a stable channel and a daily build channel.

What Claudette fills in is the operating layer the command line leaves out: branch worktrees to keep parallel agents apart, context meters to spread the usage out in the open, and a diff view plus editor that keep the review step where it belongs. It is open source, local first, and does not hold your credentials for you, at the price of remaining a shell around the official command line tool: who supplies the underlying capability, and on what terms, is still decided upstream. With one repository and one task at a time, the command line is already enough; the watershed arrives when you start handling several things at once.