Devchain v0.12.0 Release Notes

From a fixed cast to an organized team

Until now, every project shipped with the same five agents in a flat list: one Brainstormer, one SubBSM, one Epic Manager, one Coder, one Code Reviewer. If your work piled up, you waited — the Coder was a bottleneck. If your plan was complex, you got a single second opinion from SubBSM and that was it.

0.12.0 introduces Agent Teams as a first-class concept. Agents are now grouped into named teams with a designated team lead. The new teams-dev template ships two teams out of the box — Planning (led by the Brainstormer) and Builders (led by the Epic Manager) — and the team leads do real management: they spawn the right workers for the job, route by task complexity, and reuse idle members instead of reassigning blindly.

Chat sidebar with the Planning and Builders teams grouped under their leads, plus a Code Reviewer outside any team

The Chat sidebar grouped by team — Planning under Brainstormer, Builders under Epic Manager

Planning team — parallel planning by default

New in 0.12.0

Parallel independent planning — for large or architecturally novel tasks, the Brainstormer can broadcast the user's raw request to every other member of the Planning team. Each member runs its own research and produces its own framing in parallel. Diverse perspectives, not validation. The Brainstormer reconciles, picks the strongest framings, and only then enters technical validation. This was not possible before — the previous flow was capped at one fixed peer (SubBSM).

The Planning team starts with two members: Brainstormer as the team lead and one Architect peer. That single peer already changes plan quality — but the real upgrade is that the Planning team is now scalable. Click the + button on the team and you can add another Architect using any provider config you want: Opus, Opus 4.6, GPT high, Codex high, Gemini 3, OpenCode — whatever you have.

Provider config dropdown after clicking + on the Planning team — opus, opus46, gpt-high, codex-xhigh, gemini3, opencode

Add an Architect to the Planning team with any provider config

Planning team now has 2 Architect members — one on gpt-high and one on opus46

Two Architects on different models — two independent framings

Each extra Architect is a different mind on the same problem. When the Brainstormer asks the team to research independently, you get N parallel framings instead of one, with N different model strengths covering each other's blind spots. For ambiguous or cross-cutting work, this is the difference between a plan that holds up and a plan that breaks during execution.

How the broadcast works

The Brainstormer hands the user's request to the rest of the Planning team and they each go research independently. Replies come back as chat messages and are reconciled into the master plan. Validation rounds work the same way — so adding planners scales both ideation and review.

Builders team — smart auto-scaling

New in 0.12.0

Tier-aware routing. The Builders team lead (Epic Manager) doesn't just spawn Coders — it picks the right tier for each task. Cheap tasks get cheap configs. Architecture-grade work gets smart configs. Idle workers get reused before new ones are created. Related tasks batch onto the same agent to preserve loaded context. You stop paying smart-tier prices for trivial sub-epics.

Pick your providers up front

When you create a project from the teams-dev template, a Configure Teams dialog asks which provider configs the Builders team is allowed to use. Pick Claude only, Codex only, or both — mix and match by model tier. The team lead is then bounded to that allowlist when it spawns workers.

Configure Teams dialog showing the Builders team with Claude (opus46, sonnet) and Codex (codex-high, codex-medium) configs both selected

Configure Teams — pick the provider configs Builders are allowed to use

Workers appear when work appears

The Builders team starts with one Coder. As epics arrive, the Epic Manager evaluates each sub-epic's complexity tier — cheap (config edits, renames), middle (UI components, schema additions), or smart (cross-module refactors, novel API design) — and decides whether to reuse an idle Coder, batch onto a busy one, or spawn a new worker at the right config tier. All within the team's maxMembers and maxConcurrentTasks caps.

Builders team auto-scaled to 3 members: Coder (sonnet), Coder (codex-high), Coder (opus46)

Builders auto-scaled to three Coders, each on a different config tier

Why this beats a fixed Coder

Cost-aware

Cheap tasks land on cheap configs. No more burning Opus tokens on a barrel export.

Context-aware

Related tasks in the same module batch onto the same agent — loaded context is reused, not rediscovered.

Parallel-ready

Genuinely independent work runs in parallel lanes; nothing is forced to serialize.

Bounded

Capacity caps keep the team from sprawling. Replace, don't accumulate.

You're still in charge

Autonomous scaling is a default, not a lock-in. Every team can be steered manually.

Clone, delete, restart any agent from the sidebar

Right-click any team member to clone it (carries the same role and provider config), delete it, restart its session, or open the provider menu to switch configs. Team membership is no longer fixed by the template — it's a live roster.

Right-click context menu on a Coder showing Provider Config, Context tracking, Clone, Restart session, Launch session, and Delete options

Right-click any team agent to clone, restart, or delete

Edit team capacity and disable autonomous creation

Right-click a team header and pick Edit team to adjust Max team members, Max concurrent tasks, and toggle Allow team lead to autonomously create team agents. Turn the toggle off and the team lead stops spawning workers entirely — you decide every roster change yourself.

Edit team Builders dialog with Max team members 5, Max concurrent tasks 2, and Allow team lead to autonomously create team agents toggle on

Edit team — capacity caps and the autonomous-creation toggle

Recommended replacement for `5-agents-dev`

The new teams-dev template is a smart, cost-efficient upgrade over 5-agents-dev for new projects. Same SOPs, same review flow, but the agent structure is materially better:

Cheaper on average

Tier-aware routing means trivial tasks no longer pay smart-tier prices.

Faster on parallel work

Builders scale with the workload; Planning runs N research streams in parallel.

Better plans

Independent planning across multiple model families instead of one fixed peer.

Cleaner mental model

Two team leads with clear ownership replace a flat 5-agent matrix.

Provider choice up front

Pick Claude, Codex, or both — configured at project creation, not retrofitted later.

No new ceremony

Existing prompts and watchers work as-is. The team layer is additive.

Existing projects keep working

5-agents-dev is still bundled and supported — nothing breaks if you stay on it. New projects should start from teams-dev; existing projects can switch when convenient. Templates are versioned per-project, so the upgrade is on your timeline.

Full Changelog

Agent Teams: teams and team_members as first-class concepts; per-project teams with optional team lead and member roster
Teams UI: dedicated /teams page (list, create, edit, disband), sidebar entry, g t shortcut, Chat sidebar grouping by team
Auto-scaling Builders: Epic Manager spawns Coders at the right config tier per task complexity, batches related work, reuses idle workers, respects capacity caps
Parallel planning: Brainstormer broadcasts the user's request to all Planning team members for independent research; reconciliation precedes technical validation
Configure Teams at project creation: per-team provider-config allowlist, plus an auto-agent toggle to enable or disable autonomous team-lead scaling
Team management UI: Edit team modal (max members, max concurrent tasks, autonomous-creation toggle), per-team config selection, Add agent quick action, agent Clone/Delete/Restart from the Chat sidebar
MCP team tools: devchain_team, devchain_teams_list, devchain_teams_members_list, devchain_teams_create_agent, devchain_teams_delete_agent, devchain_teams_configs_list; devchain_send_message resolves the caller's team automatically
Live updates: ProjectStateBroadcasterSubscriber + chat-socket integration so agent and team mutations propagate to all open clients in real time
Handlebars prompt engine: scoped template variables in prompts (is_team_lead, team_name, etc.) and in subscriber send_agent_message.text
Project import: new ProjectTeamPreconfigDialog when importing team templates — preserves provider-config selection and redacts environment values
Provider improvements: machine-global env vars with sanitized template round-trip; default CLAUDE_CODE_NO_FLICKER=1 on new and existing Claude provider rows; provider config description column; fix for MCP WARN false positives on the Providers page
Sub-epic notifications: new subscriber notifies the parent assignee when a sub-epic is created
Stronger MCP epic handoff hint: requires explicit assignment check before proceeding
Terminal: OSC 52 clipboard relay (terminal copy now reaches the system clipboard); inline-terminal corruption fix on cross-agent restart; clipboard toast styling matches other DevChain toasts
Templates: new teams-dev template (recommended); regenerated bundled exports to v1.1.21
Packaging: sync local-app dependencies to root devchain-cli; ship the new codebase-overview package with the CLI
Docs: consolidated agent-facing documentation; trimmed legacy plan docs and CLI build notes

Update

$ npm i -g devchain-cli@latest

Existing projects continue to work without changes. To try Agent Teams, create a new project from the teams-dev template — the Configure Teams dialog appears as part of the create flow.

Quick Start Guide — Teams Template

12-page step-by-step walkthrough · install → first feature shipped

Download PDF

Prefer to compare templates first? Browse all Quick Start Guides.