Agents and orchestration

Context Code has no single, all-purpose agent: for large goals, an orchestrator proposes a plan, you split it across specialist agents, and they work in parallel while you supervise.

Specialists: delegate without losing the thread

During a normal chat, the main agent can delegate subtasks to specialists (for example, one that researches the code while another prepares the changes). Each delegation shows up in the chat as its own card:

• Everything is visible: you can open each specialist’s transcript and see exactly what it did.
• Cancellable: any specialist can be stopped without bringing down the main conversation.
• You can keep talking to the main agent while its specialists work: questions, course corrections, new instructions.
• Resumable: a specialist can be picked up later with its memory intact, without redoing work.

Read-only delegations (research, search, read) need no approval; the ones that write go through the chat’s approval modes.

Specialists appear as cards in the chat: their own transcript, status, and a stop button.

Cleaning up a chat’s subagents

A chat that has delegated a lot piles up subagents in the sidebar. To clear it out:

• A single one: hover over it and press the X, or right-click → Delete subagent.
• The ones already finished: right-click the parent chat → Delete finished subagents (N).
• All of them: right-click the parent chat → Delete all subagents (N).

It always asks for confirmation, and tells you exactly what it takes with it: ““X” and its whole conversation history will be deleted. The chat and the other subagents are untouched. This cannot be undone.” When deleting in bulk, the ones still running are kept and the app tells you so.

A running subagent isn’t just deleted

If it’s still working, its events would keep arriving at a chat that no longer has it. So the app lets you choose between “Stop and delete” — which stops the whole chat’s turn, and with it all its subagents — and “Just stop”, which stops it and leaves it there. Nothing is deleted behind your back.

Plan first, run second

For multi-step goals, the flow is plan-first:

1. Describe the full goal in the orchestrator chat.
2. The orchestrator proposes a plan broken into tasks and shows it to you before touching anything.
3. Review it (you can ask for changes) and hit Launch.
4. The tasks run — in parallel where possible — and each work thread opens in its own tab, so you can follow every agent separately.

The history of earlier plans stays available for reference.

The orchestrator proposes; you approve and hit Launch.

Custom agents

You can create your own agents with the Create Smart Agent button (global, available across all your projects):

• General: name, description, and color.
• System Prompt: its standing instructions (at least 20 characters — make them say something real).
• AI Engine: which provider and model that agent uses, independent of the chat.
• Tools: what it can touch, with quick presets — All, Read only, Code, Git.

That way you can set up, say, a strict code reviewer on a powerful model and a cheap searcher on a local model, then combine them in the same team.

Tip

Each agent can have its own provider. Combined with Auto mode, a team survives exhausted quotas by rotating profiles without stopping.

More from this screen

Every step carries its role, its editable prompt, its engine, and which other steps it depends on.

On start, each specialist opens its own thread: you see who finished and who is still working.

The timeline keeps a record of everything: start, subagents, results, and cancellations.

Each specialist has its own subchat: the parent only receives the final report.

The agent team: roles with their specialty, ready for the orchestrator to hand out.