How to Build a Multi-Agent Worker Team in Panda Code

Panda Code's architect/worker team mode lets one architect agent split a coding task and dispatch multiple worker agents in parallel, each running in a fresh context on a separately assigned harness and model such as Claude Code, Codex, Kimmy, Open Code, GLM or Muse. Writing workers must declare a narrow file scope before starting, and Panda Code runs workers sequentially rather than in parallel when their scopes overlap. The guide ties the two-mode design to an Anthropic article published in October 2026, "When to fold sub agents into your main agent loop" by Diane Sarkis, which argues most teams over-use sub-agents and add cost and latency without improving quality, and recommends defaulting to a single chat unless parallel work, a real file split, a separate verification pass or a task too long for one context window justifies a team.

How to Build a Multi-Agent Worker Team in Panda Code A practical guide to Panda Code's architect/worker team mode: assigning models per worker, scoping files, chaining tasks, and when to skip it. What is a worker team in Panda Code? A worker team in Panda Code is a setup where one architect agent, running in your main chat, plans a coding task, splits it into assignments, and dispatches several worker agents to handle pieces of it in parallel. Each worker runs in its own fresh context rather than seeing your whole conversation. It gets a bounded assignment, completes it, and reports back a summary. The architect reviews what comes back and decides what happens next. Panda Code also supports a simpler single-agent mode, where the architect just answers and edits directly with no delegation at all. That choice, team versus single agent, sits at the center of a wider debate going on in agent design right now. An Anthropic article published in October 2026, “When to fold sub agents into your main agent loop” by Diane Sarkis, argues that most teams over-use sub-agents by copying their org chart into their agent architecture: a billing team gets a billing sub-agent, a support team gets a support sub-agent, an orchestrator sits on top routing between them. It looks tidy on a diagram but often adds cost and latency without improving quality. Panda Code’s two modes map almost exactly onto the fold/don’t-fold decision that article describes, which makes it a useful lens for thinking about when a worker team actually earns its keep. TL;DR - Progressive disclosure is the core idea behind folding sub-agents back into one loop: an agent starts with short descriptions of skills and tools and only loads the full details when a task actually needs them, which keeps the main prompt lean. - Panda Code gives you both options one decision apart , letting you run a single chat for most tasks and spin up a full architect/worker team only when you can name a specific reason for it. - Each worker in a Panda Code team can run on a different harness and model Claude Code, Codex, Kimmy, Open Code, GLM, Muse, and others , which lets you put expensive models only where they matter and cheaper models on bulk work. - Writing workers declare a narrow file scope before they start , so one worker can own data logic, another the interface, another the tests, with overlapping scopes forcing Panda Code to run those workers sequentially instead of in parallel. - Worker dependencies and follow-ups let you chain work without losing context : a review worker can wait for a writing worker to finish, and a follow-up sends a correction into a worker’s existing context instead of starting a fresh one from zero. - Teams cost more in tokens and lose some detail at every handoff , so the practical rule is to default to a single chat and only reach for a team when you can point to parallel work, a real file split, a separate verification pass, or a task too long for one context window. Everyone else built a construction worker. We built the contractor. One file at a time. UI, API, database, deploy. How does the architect/worker pattern actually work? The architect is the agent sitting in your main chat. It plans the task, breaks it into assignments, and dispatches workers in a batch rather than one at a time. Workers don’t inherit your full conversation history. They start from a bounded assignment defined by the architect and nothing else, which keeps their context small and focused. Workers come in two basic flavors. Read-only workers inspect and review code without making changes, and they can run alongside workers that are actively writing. Writing workers declare a file scope up front, a narrow slice of the codebase they’re allowed to touch. If two writing workers claim scopes that overlap, Panda Code won’t run them at the same time. It queues them sequentially instead, which avoids one worker clobbering another’s edits. It’s worth noting that scope is advisory rather than a hard sandbox. It’s a strong convention for keeping workers out of each other’s way, not an enforced wall, since all workers share the same checkout on disk. You can also wire dependencies between workers, so a review worker only starts once the worker it’s reviewing has finished. And when a worker’s output is close but not quite right, a follow-up sends your correction into that same worker’s existing context rather than spinning up a brand-new worker that starts from scratch. That distinction matters more than it sounds: a follow-up preserves what the worker already learned about the task, while a fresh worker throws that away and pays the cost of relearning it. Why assign different models to different workers? Each worker in a Panda Code team can run on its own harness and model, with its own effort setting. Options include Claude Code, Codex, Kimmy, Open Code, GLM, and Muse. That means you don’t have to put the same model on every seat. A common pattern is a strong model as architect, handling planning and review, with cheaper models assigned to workers doing more mechanical or bulk work like repetitive edits or straightforward test writing. Panda Code also lets you save team profiles, so a configuration you like say, a capable architect paired with a couple of lower-cost workers becomes a single click next time instead of something you reassemble by hand. For anyone tracking spend, this per-worker model assignment is the main lever: you decide where expensive model time actually goes rather than paying premium rates for every step of a task. When does a worker team genuinely help? A few situations come up repeatedly where a team outperforms a single chat: Parallel research across a codebase. Sending out several read-only workers lets you investigate different parts of a project at once, with each one returning a short report while your main chat stays uncluttered. Remy is new. The platform isn't. Remy is the latest expression of years of platform work. Not a hastily wrapped LLM. Feature builds with a natural split. One worker handles the data layer, another the interface, another the tests, and a separate review worker checks the finished result with a fresh perspective. This also covers the verification case the Anthropic article highlights: a fresh agent checking work it didn’t produce catches mistakes the original author might talk itself out of. Model comparison. Running the same prompt across different models side by side is a fast way to see which one handles a given task best. Bulk edits. A cheaper worker model can grind through repetitive changes while a stronger model is reserved for planning and review. Long tasks that would overflow a single context window. Splitting the work across workers means each one only carries its own slice, while the architect holds the overall thread. When should you skip the team and stay in one chat? The flip side matters just as much. For a single-file typo or a small config fix, spinning up a team is pure overhead with no upside. For interactive work where you want to review every step as it happens, a single chat keeps you in the loop instead of handing you a finished result after the fact. Debugging one failing test, where each attempt builds directly on the last, works better in one place with shared state rather than split across workers that don’t see each other’s progress. The same logic applies to quick questions about code already sitting in your context, and to edits that repeatedly touch the same file: work that chains on its own prior steps and shares data belongs in the main loop, not spread across handoffs. This lines up with the broader point from the Anthropic article: split by context, not by problem type. Give a separate agent work that needs very little from the rest of the system and that can hand back one compact result, like independent research or a black-box check on finished work. Don’t split just because a task has multiple logical parts. Is a worker team worth the cost? Every worker is another model run, so a wide team burns tokens noticeably faster than a single chat, especially if every seat runs a strong model. Workers also report back in bounded summaries, which means some detail is lost at every handoff, similar to the “telephone game” failure mode the Anthropic article describes for chained sub-agents. And because all workers share the same checkout on your machine, file scoping isn’t optional risk management, it’s the main thing preventing conflicting edits. The trade is real: a team buys you parallel time and a second set of eyes, and you pay for that in tokens and some lost detail at each handoff. The practical rule is to default to a single chat and only reach for a team when you can name the specific reason: parallel research, a genuine file-level split, a separate verification pass, or a task too long for one context window. If you can’t name the reason, staying in the main loop is usually the faster and cheaper call anyway. Frequently Asked Questions What’s the difference between Panda Code’s single-agent mode and team mode? - ✕a coding agent - ✕no-code - ✕vibe coding - ✕a faster Cursor The one that tells the coding agents what to build. Single-agent mode is one architect chat handling planning, editing, and answers directly with no delegation. Team mode has that same architect dispatch multiple workers, each with their own context, model, and optional file scope, to handle pieces of a task in parallel. Can different workers use different AI models in the same team? Yes. Each worker can run on a different harness and model, such as Claude Code, Codex, Kimmy, Open Code, GLM, or Muse, each with its own effort setting, which lets you control cost by matching model strength to task difficulty. Does Panda Code enforce file scopes between workers? File scope is advisory rather than a hard sandbox. Writing workers declare a narrow scope before starting, and Panda Code runs workers with overlapping scopes sequentially instead of in parallel, but all workers ultimately share the same checkout on disk. What happens if a worker’s output is almost right but needs a fix? You can send a follow-up into that worker’s existing context rather than creating a new worker from scratch. This preserves what the worker already learned about the task instead of paying to relearn it. When is it better to just use one chat instead of a team? For small, single-file fixes, interactive step-by-step work, debugging a single failing test, or any task where each step depends heavily on shared state and prior context, a single chat is usually faster and cheaper than coordinating a team.