Skip to content
Browse documentation

Agents

Speed modes and parallel requests

Choose how much thinking the team spends, and let requests of one project run side by side in separate Git worktrees.

The speed mode sets how much thinking the team spends on each request and meeting reply. Parallel requests let a request that would otherwise wait for another one in the same project work in its own Git worktree instead.

Choose a speed mode

ModeWhat changes
Ultra-fastThe coordinator picks the agents it needs; every stage runs once on the fast model at low effort, kept as shallow as possible. No correction rounds or automatic Git stages. Meetings: one speaker, no moderator.
BalancedCoordination and Git stages on the fast model; work stages on your model at medium effort, one correction round at most. Meetings: up to two speakers, short answers.
Big brain (default)Your models and effort settings, full planning, review and Git stages, as configured.
  • Switch modes with the speed switch in the header (Ultra-fast, Balanced, Big brain), or in Quick actions (Ctrl/Cmd+K) with Speed: Ultra-fast, Speed: Balanced or Speed: Big brain. The choice is saved with the project’s settings.
  • A change applies to the stages and replies that start next. Running ones finish as they began.
  • In Ultra-fast mode, before-work and after-completion stages, such as a Git Manager’s branch preparation and commit, are skipped. Stages also receive instructions to read only what they need and keep reports short.
  • Outside Big brain, the activity feed shows the mode, model and effort a stage uses.

Set a fast model per connection

In Settings → Connections, each connection has a Fast model field. Stages that run on the fast model use it. When it is empty, Claude Code uses Sonnet, an Anthropic API connection uses Claude Sonnet 5.5, and other connections use their normal model. For ChatGPT, choose the fast model from the list; for Codex CLI and Claude Code, pick a model or keep the default option.

Run requests in parallel

Requests that prepare Git, for example with a Git Manager agent, cannot share the project folder with another running request of the same project. Settings → Project → Git workflow → Run requests in parallel (one worktree each), on by default, lets such a request work in its own Git worktree instead of waiting. Save settings to apply a change. Turned off, these requests run one at a time.

  • The request gets a worktree in .vopit/worktrees/<id>, on its own branch named from your feature branch template. It starts from the branch you chose, the one checked out in the project folder, never from the unfinished branch of another request still checked out there. With After a successful request set to Leave it on its branch, it starts from whatever the project folder has checked out.
  • Agents, project tools, change tracking and the Git agent use that folder. Project memory and the code graph stay with the project.
  • The request records “Runs beside another request of this project, in its own worktree on <branch>”, followed by the files copied into it and those that could not be.
  • When the request succeeds, its branch goes back into the branch you chose, as described below.

Finished work goes back into the branch you chose

The branch checked out in the project folder is the one you work on: main, preprod, test or any other. Each request starts its own branch from it and, once it succeeds without open points, goes back into it. To move the team to another branch, check that branch out from Source control: the next requests start from it. Settings → Project → Git workflow → After a successful request decides what happens to a finished branch. Every project uses Merge back automatically unless you choose otherwise.

ChoiceWhat happens
Merge back automaticallyVopit merges the request branch into the branch it started from, on this computer, then deletes it. Nothing is pushed. A fast-forward is used when possible, otherwise a merge commit named Merge <branch>: <request title>.
Wait for my reviewThe branch waits. The request shows Waiting to go into <branch> with Merge into <branch>, and its board card shows Not merged yet. With a To review column on the board, the card waits there and moves to Done once merged.
Leave it on its branchNothing is merged. A request on a branch other than main or a protected one commits straight on it, and the next requests continue from the project folder’s current branch, as in earlier versions.
  • After a request in the project folder, the folder goes back to the branch you chose, so the next request starts its own branch from it instead of piling up on the previous one. If one of your uncommitted changes blocks the switch, the folder stays where it is.
  • A request started while you were on preprod goes back into preprod, even if you switched to test meanwhile. A request that fixes the open points of an earlier one continues on its branch and goes where that branch came from.
  • Conflicts are detected before anything changes, so a conflicting branch leaves your branch and every folder as they were. The request shows Conflicts with <branch> and the files involved. Let the team re-apply it starts a request in which the team re-applies that work on the current state of your branch, with the request branch’s diff attached; once that request is merged, the first one shows Re-applied in <branch>. Try again merges again, for example after you fixed the conflict yourself.
  • Vopit merges in the folder that has your branch checked out, and Git refuses rather than overwrite one of your local changes; your staged files are never merged in. When your branch is not checked out anywhere, only its reference moves.
  • A board card waits for the cards it starts after until their branches are merged back, so it never starts without the work it depends on.
  • The status bar, bottom right, shows Target with the branch you chose, even while the project folder is on a request branch, and Task with the branch of the selected request (or of the running ones) pointing to it. Click Target to open Source control, Task to open the request.
  • The status bar shows N to merge while finished requests are not merged back yet. Click it to open the merge queue: the target branch drawn as a trunk, each waiting branch forking from it and coming back where it would merge, oldest first, with its commits, files and how far the target moved on since. From there you merge one branch or all of them, let the team re-apply a conflicting one, or open its request.
  • Don’t merge takes a branch out of the queue without merging it: the branch stays in Git, the request shows Not merged, and cards waiting for it go on. Put back, in the queue’s Not merged list or on the request, returns it to the queue.
  • Merge finished branches, under the same setting, merges every waiting branch of the project, oldest first, including requests that finished before Vopit merged branches. It stops at the first conflict.
  • Merge & rebase set to Never in Settings → Permissions keeps every branch waiting. Projects with linked folders are not merged automatically.

Bring ignored files into worktrees

A worktree holds only committed files. Files and folders Git ignores in the project folder, such as local check scripts, downloaded fixtures or .env files, are not there, and agents are told so. An agent that needs one reports it as a blocker instead of recreating it.

To give worktrees an ignored file or folder they need, list it under Settings → Project → Git workflow → Copy into request worktrees, one path per line relative to the project (for example _check). Each new worktree gets a copy, and its agents are told which paths were copied.

  • Only paths Git ignores are copied, so copies never appear as changes to commit and the worktree is still removed at the end. A path Git does not ignore is skipped: commit it instead.
  • .env files, private keys (.pem, .key, id_rsa…), .npmrc, .netrc, credentials files, nested .git folders and symbolic links are never copied, even inside a listed folder. Paths outside the project, .git and .vopit are refused.
  • Up to 30 paths, and 5,000 files per path. A copy is made when the worktree is created; changes made later in the project folder do not reach it.

When a request waits instead

When a separate worktree is not possible, the request waits for the other one and shows the reason as “Waits for “<request>”: …”. A worktree that could not be created is attempted again after 60 seconds, so committing the project in the meantime lets the request start.

ReasonWhat to do
Parallel requests are off in this project’s Git settings.Turn the option on, or let requests run one at a time.
Its branch is already prepared in the project folder.A resumed request keeps working where its branch is.
The project has no Git repository, or the repository has no commit yet.Initialize the repository and commit the project once.
The project has linked folders.Projects with linked folders run their Git requests one at a time.
Uncommitted files in the project folder would be missing from a separate worktree.Commit them. A worktree contains only committed files; ignored files it needs can be copied (see above).

Clean up worktrees

  • When a request finishes without open points, its worktree is removed if nothing is left uncommitted in it. The branch keeps any commit; a branch that never moved is deleted.
  • If uncommitted changes remain, the worktree and branch are kept and the request lists an open point with their location. Commit or merge them from there.
  • A request with open points keeps its worktree: Fix open points continues in the same worktree and branch.
  • Deleting a request releases its worktree when it holds no uncommitted change; otherwise the worktree stays for you to inspect.

All documentation