The problem
Your monorepo has natural parallelism — API, frontend, shared libs, workers — but your agents can't exploit it. You run one agent at a time, manually decompose cross-service features, and resolve merge conflicts when parallel experiments collide.
"At one point we tried cloning our repo into three directories and running Claude in each of them, but it felt like driving a Subaru with a jet engine strapped on."
— Madewithlove blog
The raw power is there. The coordination isn't. Cross-service features that should take one afternoon take two days because agents work sequentially and create merge conflicts.
"demands manual task decomposition, merging isolated branches requires manual intervention"
— Nathan Norman on the status quo of multi-agent monorepo work
How Chief helps
| Pain point | Chief feature | What you get |
|---|---|---|
| Multiple services that could be worked on in parallel but aren't | Parallel agent dispatch with dependency-aware sequencing | Three agents work on three services simultaneously — with Chief handling the execution order |
| Context starvation — agents don't see the full monorepo | Project-level context shared across agents | Every agent knows about shared types, service boundaries, and cross-service contracts |
| Cross-service dependency management | Intelligent task decomposition with dependency graph | Chief sequences shared-types-first, then API, then frontend — so agents build on stable foundations |
| No visibility into parallel agent work across services | Unified dashboard with per-agent progress tracking | See what every agent is doing across every service from one view |
| Manual task decomposition for multi-service features | Goal-to-task breakdown with per-service routing | Set a feature-level goal and Chief proposes the per-service tasks automatically |
Why monorepos are the best case for multi-agent parallelism
1. Dependency-aware decomposition
Monorepo features have natural dependency chains: shared types before API before frontend. Chief understands these dependencies and sequences tasks accordingly, instead of making you decompose work manually. This is Chief's core workflow — set goals, approve plans, agents execute — applied to multi-service architecture.
2. Agent routing by service
Different services benefit from different agents. Chief routes Claude Code to your backend, OpenAI Codex to your frontend, and Qwen Code to your worker — all in parallel where dependencies allow. You already intuit that different agents suit different services — Chief makes this explicit and automated.
"seamlessly switch between Codex for heavy backend stuff and Claude code for everything else."
— HN user on multi-agent workflows
3. Unified visibility across services
When multiple agents work in parallel, you need to know what's happening everywhere. Chief gives you a single dashboard showing agent progress per service — which tasks are in flight, which are complete, which need review. Unlike manual orchestration tools that leave you switching between terminal tabs, Chief surfaces all parallel work in one view.
4. Full-repo context, scoped execution
Agents get project-level context about the entire monorepo while working within their assigned service scope. No more agents creating files that already exist or duplicating shared utilities.
"If you add a directory to your Cascade, it's reluctant to actually read all the files in the directory...It's very annoying to have the LLM try to create a file that already exists, it just didn't know about it."
— Yusefmosiah, HN
5. One goal, multiple services
Set "Add team invite flow with email notifications" as a single goal. Chief handles the decomposition across API, frontend, worker, and shared packages — the same proactive planning that distinguishes Chief from manual orchestrators, applied to monorepo-scale work.
"The skill isn't coding faster. It's knowing what can happen simultaneously."
— Emma Williams, Madewithlove
Example: "Add team invite flow with email notifications"
Monorepo: Four packages — API service, web frontend, shared types package, and email worker service.
1. Set the goal. Enter the feature goal in Chief: "Add team invite flow with email notifications." No manual decomposition needed.
2. Chief decomposes. Chief analyzes the monorepo structure and proposes four tasks, sequenced by dependency:
- Task 1: Add
TeamInvitemodel and types topackages/shared-types(no dependencies — runs first) - Task 2: Add
POST /invitesAPI endpoint + DB migration toservices/api(depends on Task 1) - Task 3: Add invite email handler to
services/email-worker(depends on Task 1) - Task 4: Add invite UI flow to
apps/web(depends on Tasks 1 and 2)
3. Parallel dispatch. Once shared types land, Chief dispatches three agents in parallel — Claude Code to the API service, Claude Code to the email worker, OpenAI Codex to the frontend. Each agent has full monorepo context but scoped execution to its assigned service.
4. Unified visibility. Chief shows all three agents' progress in one dashboard — Claude Code on services/api/ and services/email-worker/, Codex on apps/web/. You see what's in flight across every service without switching terminals.
5. Review. All three service PRs appear in Chief's dashboard with diffs attributed to the agent that wrote them. Review the API endpoint, the email template, and the invite UI — all from one view. The shared types are already merged, so all three PRs build cleanly.
When to use Chief
- Your monorepo has 3+ services or packages and you're only running one agent at a time because coordinating parallel work is too painful.
- Cross-service features take days instead of hours because you manually decompose work, run agents sequentially, and resolve merge conflicts afterward.
- Your agents keep creating files that already exist or miss shared utilities because they can't see the full monorepo context.
- You already use different agents for different tasks (e.g., Claude Code for backend, OpenAI Codex for frontend) and want to formalize this into automated routing.
- You want to set a feature-level goal and let the tool handle per-service decomposition, dependency sequencing, and parallel execution.
One goal. Multiple services. Full visibility.
FAQ
Does Chief understand my monorepo's package structure?
Chief analyzes your monorepo layout and understands the relationships between packages and services. It works with Nx, Turborepo, Lerna, or custom workspace configurations — whatever your monorepo uses.
How does Chief coordinate parallel agents across a monorepo?
Chief sequences work by dependency — shared types ship before the services that depend on them. Parallel agents work on separate services simultaneously, and Chief shows you all progress in one dashboard. This dependency-ordered sequencing is the same workflow that gives Chief an edge over manual orchestrators and terminal multiplexers.
Can I assign different agents to different services?
Yes. Chief's BYOA (bring your own agent) model lets you route any agent to any service. Assign Claude Code to logic-heavy backend work, use Codex for frontend components, and route another agent to worker services. Chief coordinates all of them from one dashboard — using your existing subscriptions with no new vendor lock-in.
Does Chief work with Nx, Turborepo, or other monorepo tools?
Yes. Chief is monorepo-tooling-agnostic. It coordinates agents that work within your existing build system — the agents themselves handle framework-specific tooling, and Chief handles decomposition, dispatch, and coordination.
How does Chief handle shared dependencies between packages?
Chief sequences shared dependencies before dispatching parallel work. Shared types, schemas, and utility packages are updated first in dedicated tasks. Only after those changes pass quality gates does Chief dispatch agents to dependent services.
What happens if one agent's work breaks another service?
Each task has acceptance criteria. If an agent's output fails the quality gate — test regression, type error, broken contract — Chief flags it before dependent tasks proceed. The failure is contained to the affected service, not propagated across the monorepo.
Is Chief free for monorepo projects?
Yes. Chief is free to start with no credit card required. You bring your own AI agent subscriptions — Chief manages them without adding another bill. Paid plans unlock advanced features like cross-package dependency orchestration and enhanced parallel scheduling as your monorepo scales.
Can Chief handle monorepos with 10+ packages?
Yes. Chief's value scales with monorepo complexity. More packages means more parallelism opportunities — Chief decomposes across all of them, dispatches agents to independent packages simultaneously, and sequences dependent work automatically. The ceiling is your agent budget, not Chief's coordination capacity.