Going parallel

Handing work to an agent

Send a task to a background coder that works on its own branch while you keep going.

“/a”

The active plan and every open task go to durable background execution.

“/a add pagination to the projects endpoint”

That specific task, handed to a coder, on its own branch.

“Ctrl+D”

Agent Center: what's running, what finished, what it changed.

What an agent is

A separate worker that owns the complete scope you assign. A quick launch may be one task; a selected plan or ticket keeps its full ContextStream IDs. By default it gets its own git worktree, so it can't collide with your working tree — or with another agent. You keep typing while it works.

The agent does not stop after the first convenient subtask. It continues from one actionable assigned item to the next without waiting for another “continue”. A run is successful only when every scoped item is verified complete. If something is genuinely blocked, the receipt names that exact item and blocker while independent work continues.

The specialists

Different jobs get different agents. You don't usually pick; the right one is chosen for the task.

Agent	What it's for
Coder	Implementing a change
Explorer	Understanding how something works
Planner	Breaking a goal into ordered pieces
Reviewer	Reading a diff critically
Designer	Interface critique and design systems
Prototyper	Building working UI, fast
Lead	Coordinating the others

Designing an interface and Building a prototype cover the two you do invoke directly.

Agent Center

CtrlD opens it. Tab moves between four views:

Runs — everything live and finished, refreshing as it goes. g pins a run, x twice stops it, r twice reruns it fresh, d twice removes a finished receipt, c twice cleans finished history into recoverable trash.
Live Grid — up to nine agents at once in a 3×3 view. a adds work, d unpins a tile.
Launch — start work with the options laid out, and choose whether it lands in the Grid or in Runs. Selecting a plan, task, or ticket freezes its full IDs as the authoritative work set.
Templates — saved setups. They load into Launch for review; they never start on their own.

CtrlE expands and shrinks the panel. Ctrl] closes it.

Permission prompts still come to you

An agent that needs approval asks through your normal prompt queue, tagged with which agent is asking. Work doesn't stall silently waiting for someone to notice.

Agents outlive your terminal

Runs are owned by a per-user daemon that any surface starts on demand. Launch from the terminal, watch from the VS Code Agents tab, close the terminal — the work carries on. Reopen and it's there.

Set CONTEXTCODE_AGENT_DAEMON_AUTOSTART=off if you'd rather that didn't happen.

Reviewing what comes back

Nothing lands in your branch on its own. A finished agent presents its diff and waits for a one-key review merge. See Working on a branch without leaving your session for what merging does.

The chat notice is also a durable execution receipt. It includes the full run ID, each assigned item's outcome, verification evidence, changed files, commit/branch/PR state, and any live or local URL with exact access instructions. It also says what remains. Open the complete record at any time:

Code

/agent show <run_id>
/agent pause <run_id>
/agent resume <run_id>
/agent steer <run_id> <instruction>
/agent cancel <run_id>

In the dashboard, that receipt stays attached to the response that owns the run. It says Working Now, Completed, or Needs attention without making you infer status from prose. Expand it in place to see the assignment and live activity; choose Agents to open the shared Agents panel.

Agents opens on Working Now by default. Finished work moves to Recent with a readable completion time and an explicit Completed state. Choose any card to inspect the executor-owned outcome, verification checks, changed files, pull request or commit, and live or test URLs. Those details are stored with the run, so switching projects, reconnecting, or coming back later does not turn completed work into an anonymous transcript card.

The current chat receives the same run snapshot plus a bounded catalog of the real work threads established in that conversation. Luna interprets the meaning of each follow-up against those threads and returns only an opaque thread key, unrelated work, an explicit project-wide request, or ambiguity. ContextCode validates that key and binds the exact host-held plan, task, ticket, and run IDs. If the current message itself contains a labeled list such as Ticket <UUID>, the host turns those exact references into one bounded current-turn candidate immediately—before any durable transcript replay. You do not need a new session or to reattach scope already written in the message. The candidate catalog gives the routing model only opaque keys and semantic labels, not its host-held IDs. IDs literally typed in the prompt remain user-authored text, but the model cannot return one as a selector or substitute a different scope.

This is not a list of English trigger phrases. Topic references, corrections, pronouns, paraphrases, and other languages can all select the right thread. “Are all the tickets done?” can therefore resolve to the tickets assigned to a run without turning into a list of every project ticket. If two threads are genuinely plausible, ContextCode asks which one you mean. It widens to the project backlog only when you explicitly ask for project-wide work.

Reviewing from the dashboard

In an Agent session, choose Code beside the session controls. The explorer opens against that session’s live checkout, without replacing the chat:

changed files stay marked in the tree, with changed counts rolled up through their folders;
choosing a changed file opens its real checkout diff first, with additions, deletions, hunks, and git state;
File switches to the current source in a read-only, syntax-highlighted editor; and
files with no Agent changes still open from the live checkout for ordinary code browsing; without a live session, the explorer falls back to indexed project source.

On desktop, Code uses the full dashboard width while keeping the session-level close control anchored to the project tree. Use the icon at the far left of the file toolbar to hide the project tree when you want the source or diff to fill the workspace; choose it again to restore the same tree without losing the selected file or live Agent session.

Use the changed-files filter in the explorer header when you only want the review set. Closing the explorer returns you to the same live Agent session.

If a temporary model or connection problem ends a dashboard response early, choose Retry on that response. ContextAgent resends the same request and attachments in the same live session, and prevents another retry while the replacement turn is active. Retry is intentionally absent when the response needs an access, checkout, permission, or completion-review issue resolved.

If it doesn't work

An agent is stuck. Check Runs — it's usually waiting on a permission prompt. Answer it and the run continues.

Two agents changed the same file. They work in separate worktrees, so this surfaces as a merge conflict at landing time, not as corruption. Resolve it where it appears.

I can't find a run I started yesterday. Runs keeps receipts. If you cleaned history with c, it went to recoverable trash rather than being deleted.

A dashboard response stopped before it finished. Choose Retry on the response. It continues from the same session and checkout; if Retry is absent, the blocker needs a changed condition rather than the same request again.