Agentic Coding Tools

Subagents and Parallel Agents: Workflows That Actually Scale

Subagents and parallel agents let one engineer run several focused agent tasks at once, either as helpers inside one session or as independent sessions working side by side. They scale well for independent, verifiable work, and poorly for tightly coupled changes, because the real bottleneck shifts from writing code to reviewing it.

neooutput editorial team 4 min read Auf Deutsch lesen

Subagents vs parallel agents: what is the difference?

Subagents are helpers spawned by a main agent with their own context for a focused job; parallel agents are separate sessions working on separate tasks at the same time.

In Claude Code, subagents can be defined with their own instructions and tool permissions, for example a code reviewer, a test writer or a researcher that explores the codebase. The main agent delegates to them and receives a summary, which keeps its own context clean. Parallel agents are different: an engineer starts several agent sessions, each on its own branch or environment. Codex cloud tasks are a prominent example of parallel agents, each returning a pull request.

When subagents help

Subagents help when a subtask needs lots of reading but only a short answer, or when a specialized role benefits from its own instructions.

  • Codebase research: find all places where a function is used and summarize patterns.
  • Independent review: a reviewer subagent checks the main agent's changes with a fresh context.
  • Test writing: a dedicated subagent writes tests against a specification.
  • Documentation: summarizing changes or updating docs after implementation.
  • Log or error analysis: digesting long outputs and returning the relevant lines.

When parallel agents help

Parallel agents pay off for independent tasks that touch different parts of the code and can be verified by tests.

Good examples include several unrelated bug fixes, adding tests to multiple modules, dependency upgrades in separate packages, or exploring two alternative implementations of the same feature and keeping the better one. Poor examples are changes to the same files, features with unresolved design questions, or tasks that depend on each other's results. Running such tasks in parallel creates merge conflicts and inconsistent designs.

Practical setup for local parallel work

Git worktrees are the simplest way to give each local agent its own isolated working copy.

  1. Create a worktree and branch per task so agents never edit the same checkout.
  2. Make sure each worktree can install dependencies and run tests independently.
  3. Give each agent a precise task with acceptance criteria and the shared context file.
  4. Watch for port conflicts and shared resources such as local databases.
  5. Review each branch separately and merge in a deliberate order.
  6. Clean up worktrees after merging.

The real bottleneck: review

Parallel agents can generate pull requests faster than any team can review them carefully, so review capacity must set the pace.

A useful rule is to cap the number of concurrent agent tasks per engineer at what they can genuinely review the same day. Strong CI catches many issues automatically. Reviewer subagents or AI review tools can pre-screen, but a human remains accountable. Reject and re-scope rather than patch a pull request that went in the wrong direction; fixing a confused agent output often takes longer than rerunning a clearer task.

Costs and context

More agents mean more token usage, so parallelism should be justified by real time savings.

Subagents can reduce cost in some cases by keeping the main context lean, but they also add their own usage. Parallel exploration of alternatives doubles cost for one outcome. Track usage per team and per workflow, and use parallelism where it shortens lead time for valuable work rather than as a default.

Learning these workflows

Subagent and parallel workflows are advanced techniques that work best once a team has solid fundamentals.

In neooutput's two-day agentic coding training, teams practice defining subagents, running parallel tasks with worktrees or cloud agents and organizing review. Our AI Code Engineers use these patterns in client delivery daily. If you want to scale your team's agent usage beyond one task at a time, a short call is a good starting point.

Frequently asked questions

How many parallel agents should one developer run?

As many as they can review properly. For most engineers that is a small number of concurrent tasks; beyond that, review quality usually suffers.

Do subagents make results better or just faster?

Both are possible. A reviewer subagent with fresh context can catch issues the main agent missed, and research subagents keep the main context focused. They are not a substitute for human review.

What are git worktrees and why use them?

Worktrees let you check out several branches of the same repository in separate directories. Each agent gets its own working copy, which prevents agents from overwriting each other's changes.

Can parallel agents work on the same feature?

Only if the feature is split into independent parts with clear interfaces. Otherwise agents produce conflicting changes and inconsistent designs. For tightly coupled work, one agent with a good plan is usually better.

All insights