One generalist, or many specialists?
The default mental model for using a coding LLM is still "one chat, one model, one long conversation." It works until a task involves planning, implementation, testing, review, and documentation. Then a single conversation drags context from every phase into every other phase—the model confuses requirements with artifacts, review comments with code, and what it just finished with what it should do next.
Literature on agentic systems shows a pattern. Anthropic's multi-agent research system spawns specialist agents in parallel, each with its own context window, tools, and trajectory. On their research benchmark, this beat single-agent Claude Opus 4 by over 90%—at the cost of 15× more tokens. The takeaway is not "always go multi-agent," but that for tasks with clear sub-problems, parallel specialists outperform a monolithic conversation.
Role, skill, agent: three units of specialization
Three distinct concepts:
A role prompt is a one-off instruction: "act as a security reviewer for this diff." Ephemeral, unversioned, no trace.
A skill is a saved posture—a markdown file with a system prompt and optional tool allowlist, called via /skill-name. It doesn't persist across turns; it shifts the model's stance for one focused pass. No process overhead, cheap.
An agent owns its own context window, tools, and subprocess. It runs in parallel with other agents. CrewAI models agents as team members with roles; LangGraph uses explicit state machines; AutoGen orchestrates agents as conversation participants. Different approaches, same principle: narrow the role, sharpen the output.
Per task: do you need a long-lived role (agent), a posture shift for one pass (skill), or a single nudge (role prompt)?
What ships in the free Orchestrator
The free, AGPL-licensed VibeCoded Orchestrator ships 29 specialist agents and 28 skills out of the box. They cover the day-to-day loop of writing, reviewing, and maintaining a codebase on your own machine.
The 29 bundled agents include coder, planner, tester, helper-scripter, kg-navigator, knowledge-curator, code-graph-updater, doc-organizer, prompt-engineer, orchestrator-installer, project-bootstrapper, project-migrator, ai-agentic-architect, ai-llm-expert, backend-specialist, deep-researcher, expert-coder, frontend-specialist, gui-expert, project-architect, project-coordinator, project-organizer, code-explorer, code-migrator, doc-extractor, doc-maintainer, graph-health-checker, gui-tester, and web-explorer. Each one is a markdown file with a system prompt, a tool allowlist, and optional model and effort caps — you can read it, fork it, rewrite it.
The 28 skills cover the posture-shifting moves: /architect, /debug-expert, /security-reviewer, /tdd, /explore-codebase, /api-designer, /performance-optimizer, /ai-rag-advisor, /database-advisor, /deployment-advisor, /code-review-expert, /kg-research, /extract-docs, /fix-issue, /task-breakdown, /accessibility-checker, /react-patterns, /workflow-maintain, /context-compress and more. A skill is one command and a system prompt swap; an agent is a process.
Coordination uses the blackboard pattern: agents pull tasks they can handle from a shared store, not pushed by a manager. Research rates pull-based volunteering 13–57% better than hierarchical delegation on both token cost and parallelism. In practice, three parallel agents is the limit; more than that and context merging becomes lossy and token-wasteful.
What MAO adds (beta)
The free Orchestrator gives you the parts: 29 agents, 28 skills, the blackboard. MAO (Multi-Agent Orchestrator), currently in beta, is the runtime that wires them together.
MAO is built around the maestro: a conversational orchestration interface that you talk to like a single agent, and that delegates to the underlying specialists. Behind the maestro sits a hierarchical planner that decomposes goals into a tree of sub-tasks, a hybrid agent harness that routes individual roles across Claude / Ollama / OpenAI / Gemini depending on cost and capability, and a blackboard scheduler that lets the agents pick up work in parallel without stepping on each other. A Tauri desktop UI lets you watch the team operate in real time, approve risky actions, and redirect the plan when it drifts.
The base Orchestrator's blackboard pattern works for one or two parallel agents; the maestro is what lets you run a four-or-five-agent team end-to-end without merging context lossily.
These MAO components are not part of the free base or of Orchestrator Pro. Pro (€19/mo, €149/yr, €199 lifetime) adds RL reranking and curated agent packs to the base, with the same 29 bundled agents. MAO is a separate product, currently in beta, with pricing TBD.
Two concrete shapes
"Design and implement a new auth module." The free planner agent spawns first, breaks the work into tasks, writes them to the blackboard. The coder, tester, and a /security-reviewer skill pick tasks in parallel. A reviewer agent gates the merge. The doc-organizer updates the reference. Four specialists, one outcome, and no single context window had to hold all of it. This works in the free tier.
"Coordinate a refactor that touches frontend, backend, and the database, and produce a tradeoff doc first." You describe the goal to MAO's maestro. The hierarchical planner decomposes it: write the tradeoff doc first, then implement frontend and backend in parallel, then run integration tests. The ai-agentic-architect writes the tradeoff doc. The backend-specialist and frontend-specialist implement in parallel via the blackboard. The deep-researcher cross-references the database advisor and surfaces relevant prior art. This needs MAO's runtime — the maestro, the planner, and the hybrid agent harness — sitting on top of the same 29 agents that ship in the free base.
Where this sits in the landscape
| Tool | Built-in specialists | Parallel exec | User-extensible | Open source |
|---|---|---|---|---|
| VibeCoded Orchestrator (free) | 29 agents + 28 skills | Yes (blackboard) | Yes (markdown) | AGPL |
| VibeCoded MAO (beta) | maestro + planner runtime | Yes (hierarchical) | Yes | Commercial |
| Cursor | Composer + Agent modes | Limited | Partial | No |
| GitHub Copilot | Agent mode (single) | No | Limited | No |
| Aider | Role selection | No | Yes (CLI) | Yes |
| Devin (Cognition) | Single autonomous agent | Internal only | No | No |
| CrewAI | DIY (role-based) | Yes | Yes (framework) | Yes |
| LangGraph | DIY (state machines) | Yes | Yes (framework) | Yes |
| AutoGen | DIY (conversational) | Yes | Yes (framework) | Yes |
Most tools offer either a single agent (Cursor, Copilot, Devin) or a framework to build your own (CrewAI, AutoGen, LangGraph). The free Orchestrator is in the middle: 29 curated specialists and 28 skills—opinionated enough to work out of the box, open enough to rewrite as markdown.
When you outgrow the blackboard and need a maestro, MAO is where the hierarchical runtime, planner, and Tauri UI live.
Sources: