Personal agentic command center: a conductor agent coordinating teams of AI agents
In plain text: how a conductor coordinates teams of AI agents
By Robert Evans. Updated
Status. This page illustrates a design in progress. The teams run today inside Claude Code. Some behavior shown here, such as the conductor rerouting failures without asking you, and QA and Security filing GitHub issues, is still being built.
What is a conductor agent?
A conductor is a master agent that sits above teams of AI agents. It talks to you, picks the next team based on the documents it already holds, hands each team's output to the following team, and summarizes results for you. It never does a team's work itself.
How does work move through the system?
- You bring a feature idea to the conductor.
- The conductor calls in the Ideation team. You talk it through, and it returns a structured product brief.
- The brief goes to the Design team. You and the team mock up the feature together.
- The brief and the mockups go to the Engineering team, which builds the feature.
- QA drives a real browser like a user while Security pentests from a Kali Linux container, at the same time.
- If QA fails or Security finds an issue, the conductor sends the findings straight back to Engineering. The fixed build goes back through QA and Security.
- When both clear, the conductor summarizes the result for you.
What does each team do?
| Team | Job | Specialists | Takes in | Hands back |
|---|---|---|---|---|
| Ideation & Discovery | Turns a raw idea into an approved product brief. Nothing moves on until you approve it. | 3 | Your idea | Approved product brief |
| Design | Turns a product brief into a reviewed HTML mockup. You pick one of three directions; reviewers check the build. | 9 | Product brief | Mockup and summary |
| Engineering | Builds a feature test-first, then reviews it four ways plus a fresh-eyes pass. Shown for the Rails team. Read how this team was designed. | 9 | Brief and mockups | Feature summary |
| QA | Drives the running app in a real browser like a person would. | 6, in parallel | Build summary | QA summary and verdict |
| Security | Runs an authorized pentest from a Kali Linux container plus two passive checks, and refuses unauthorized targets. | 3, in parallel | Build summary | Security summary and verdict |
Is the order of teams a fixed pipeline?
No. Teams never call each other. Each one reads an input document and produces an output document, and the conductor chooses what runs next from the documents it holds and the ones still missing. A feature with no user interface can skip Design, for example. The order is decided during the run, not drawn in advance.
What happens when QA fails or Security finds a problem?
In this design the conductor does not stop to ask you. It sends the failed QA report and the security finding straight back to the Engineering team, then routes the fixed build through QA and Security again. Only when both clear does it come back to you with a summary.
What happens to problems a team notices outside its scope?
Agents record them as GitHub issues instead of fixing them. An engineering agent that spots tech debt, or a QA agent that sees an unrelated interface bug, files an issue and carries on with its assigned work. Scope stays fixed, and nothing that was noticed gets lost.
How is this different from graph engineering?
Graph engineering fixes the paths in advance: a developer draws nodes and edges, and one shared state moves through them. Here the unit is a whole team with its own orchestrator, and the conductor picks the next team live from the documents it holds. LangGraph also supports dynamic routing, so the contrast is one of emphasis.
| Graph engineering | Conductor and teams | |
|---|---|---|
| Unit of work | A node: one bounded step, such as an agent, an LLM call, a tool call or a human step | A team: an orchestrator plus specialist agents |
| Who draws the paths | The developer, ahead of time, with fixed and conditional edges | The conductor, live, from the documents it holds |
| What is shared | One state record that every node reads and writes | Documents handed from team to team |
Source for the graph engineering column: LangChain, "3 Years of Graph Engineering with LangGraph".
Related: The Agentic Engineering Team Playbook, which teaches how agents, skills, commands and artifacts combine into a portable engineering system.