Run five agents at once. None of them stepping on each other.

What happens when you run agents without isolation

Two agents in the same working directory will eventually collide. Agent A edits a file agent B is reading. Agent B commits something that conflicts with agent A's in-progress changes. You end up with a merge conflict in the middle of an automated run, both agents stopped, and a working directory in an unknown state.

The common workaround is to run agents sequentially. One finishes, the next starts. But sequential execution erases the entire point. You have turned a parallelism tool into a slower version of one agent.

Git worktrees: the correct isolation primitive

Git worktrees are separate checked-out working directories linked to the same repository. Each worktree has its own branch and its own file state. Changes in one do not affect any other until you explicitly merge.

This is the correct way to isolate parallel agents. Each agent lives in its own worktree, works on its own branch, and cannot touch anything outside its directory. The blast radius of a bad agent run is zero: it cannot corrupt main, collide with another agent, or leave your working state broken.

Tempest creates and manages these worktrees automatically. Open a session tab — worktree created. Close it — worktree persists. You never touch the Git worktree CLI directly.

Token cost at scale: why shared context matters

Every AI agent reads your codebase to understand what it's working with. In a single session that's expected overhead. In five parallel sessions, each agent reads the same foundational files independently — entry points, type definitions, shared utilities — and you pay the full token cost every time, for every agent.

Tempest's Token Intelligence builds a local semantic code graph from your codebase once and shares it across every parallel session. Agents query the graph for symbol definitions, call chains, and cross-file relationships instead of reading files from scratch. The foundational reading happens once. Every session after that costs a fraction.

Supported agents

Any terminal-based AI coding agent works inside Tempest. Confirmed integrations:

Session continuity: no context lost between visits

When you run multiple agents in parallel, you are not watching all of them at once. You delegate, do something else, then come back to review. If coming back costs five minutes of re-orientation per session, five sessions costs twenty-five minutes before you've reviewed a single diff.

Tempest persists every session the moment you leave it. Close a tab, reopen it — the agent picks up exactly where it left off. Full conversation history, same branch, worktree untouched. Nothing is lost because nothing was lost.

What parallel agents enable in practice

Once isolation and continuity are both handled, the way you work changes:

• Run five features in parallel and pick the best result, not the first one finished.
• Run a bug fix agent and a feature agent simultaneously — one doesn't block the other.
• Review diffs in batches. Five agents run while you do other work; review all five when they finish.
• Explore three approaches to the same problem simultaneously — all isolated, all reviewable.