Skip to content

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

Section titled “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.

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.

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.

When planning, the orchestrator receives an inventory of the project: connected MCP servers, enabled skills and whether a knowledge graph exists. If there is a graph, it queries it before splitting the work; if the goal touches the architecture, it draws it with a diagram.

Each plan step can carry the skills and MCP servers it needs. The specialist receives them at the top of its instructions, so it loads the right skill and uses the right tools without discovering them on its own. The same applies when the orchestrator delegates a single subtask.

If a specialist fails, its card shows Resume with…: pick another profile or model and it continues with its full transcript.

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.

If you ask in the chat, the orchestrator builds a team for the project (saved in the workspace’s .context/agents/) and also manages it: it can list teams, show an agent’s prompt, fix its description, prompt, tools or autonomy, and delete an agent or a whole team. Just ask: “remove the testing agent”, “delete the old team”, “give the reviewer read-only access”. Every change goes through the chat’s approval, like any file write.

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.