The router agent: deciding which specialist gets the work shapes the whole system
AI-assisted research. This note was prepared with the assistance of AI tools. It may contain errors and is not professional advice. See our Legal Disclosures.
Marketing programs that start with one agent soon add specialists for lifecycle, content, paid media, research, and analytics. Once there are several, incoming work has to reach the right one. The component that makes that decision is often called a router, and its quality sets a ceiling on everything downstream.
A request to refresh the onboarding emails should go to the lifecycle agent, not the social agent. A request that needs legal review should go to a person, not any agent. Routers are easy to overlook because they produce nothing visible, but a poor router quietly degrades every agent behind it.
What a router does
A router takes an incoming request and makes four decisions before any work starts. Each one can fail on its own, so it helps to treat them separately.
- Fit: whether the request is clear enough to route at all.
- Destination: which specialist should handle it, agent or person.
- Context: what facts, brief, and history that specialist needs.
- Priority: how urgent it is relative to other work in the queue.
In the Agentic Hub pattern, routing is one of the hub's five jobs, alongside planning, shared context, approvals, and the run log. The router reads the current plan and shared facts from the hub rather than keeping its own copy, and it records each decision in the same log everything else uses. Our Agentic Hub architecture diagram shows where it sits between people and specialist agents.
How misrouting hurts
A misrouted request rarely fails loudly. The wrong specialist usually does something plausible with it. A paid media agent asked to rewrite onboarding copy will produce copy, just without the lifecycle agent's knowledge of sequence timing and suppression rules.
The cost shows up later. A reviewer catches the problem and sends it back, or does not catch it and the work ships with a gap. Either way, the specialist looks worse than it is, and the team may spend time tuning an agent whose only fault was receiving the wrong work.
Missing context is the quieter version of the same failure. The request reaches the right agent without the brief or the approved facts, and the agent fills the gap with guesses. Our post on designing agent handoffs covers what a handoff should carry so the receiver does not have to guess.
Rules, models, or both
Routing can be done with simple rules, with a model making judgments, or with a combination. Each has a natural home.
Rules work well when requests arrive through structured channels, such as a form with a request type or a trigger from a specific system. They are fast, cheap, and predictable, and their mistakes are easy to trace.
Model-based routing handles free-text requests, such as messages in a team channel or emails from colleagues. It can interpret intent, but it will occasionally misroute, and its mistakes are harder to predict.
We recommend a hybrid for most programs. Use rules for structured requests and a model for the rest, with a fallback to a person when the model is not confident. The fallback is what keeps a model's occasional misroutes from becoming silent errors.
Design principles
A few principles make the difference between a router that helps and one that adds noise. We suggest starting with these five.
- Describe each specialist clearly: keep a short capability description for every agent and person, with examples of requests each should and should not handle.
- Allow none of the above: let the router say that no specialist fits, because forcing a choice leads to misrouted work.
- Ask one clarifying question: when a request is ambiguous, ask the requester rather than guess.
- Route people too: send legal claims, pricing commitments, sensitive customer situations, and brand crises to people by rule.
- Log every decision: record the request, the destination, the reason, and the context passed along.
Capability descriptions do most of the work. The router can only choose well if it knows what each specialist does and does not do, and the "should not handle" examples are often more useful than the positive ones. Our post on agents that handle ambiguity goes deeper on when asking beats guessing.
The router should not do the work itself. A router that starts drafting answers to simple requests becomes another specialist with unclear accountability. Keeping it narrow matches the principle we apply to the hub as a whole: coordination layers should be the most predictable part of the system.
A worked example
Consider a hypothetical B2B software company with five specialists: lifecycle, content, paid media, analytics, and a human product marketing manager. A sales leader posts in the team channel asking for "something to send accounts that went quiet after the trial."
The router has no form field to read, so it uses its model path. The request could be a lifecycle sequence, a one-off email, or a sales enablement asset. Its confidence is low, so it asks one question: should this be sent automatically, or by reps themselves. The sales leader says automatically, and the router sends it to the lifecycle agent.
It passes along the trial-expiry segment definition from the shared context, the current offer record, and a link to the original thread. It also marks the request as normal priority, because nothing in it ties to a launch date. The log records each choice and the clarifying exchange.
A week later, the team reviews a sample of routing decisions. They find two requests about pricing pages that went to the content agent when the rules say pricing goes to the product marketing manager. The fix is a sharper "should not handle" line in the content agent's description, not a new router.
Measuring a router
A router is measured by what happens after it decides. We recommend tracking four signals.
- First-route accuracy: the share of requests routed correctly on the first attempt, checked by weekly sampling.
- Specialist rejections: how often specialists return work as out of scope.
- Time to route: how long requests wait before reaching a specialist, including clarifying questions.
- Fallback rate: how often the router sends work to a person because it is not confident.
Read these together. A router can score well on accuracy and still stall on ambiguous requests, which makes it a bottleneck. A falling fallback rate is good news only if accuracy holds at the same time.
What we are studying next
As programs add specialists, capability descriptions start to overlap, and the router faces more close calls. We are studying how descriptions should be written and tested as a set, so that adding one agent does not quietly change where existing work goes.
How to apply this: write a one-paragraph capability description for each of your agents and the people they route to, including what each should not handle. Even before you build a router, those descriptions will reduce confusion about who does what.
Related research
Multi-agent content pipelines: researcher, writer, editor, checker
Splitting content creation across specialized agents mirrors how editorial teams already work, and makes each step easier to test, measure, and improve.
Event-driven orchestration: triggers, queues, and retries for marketing workflows
Marketing work starts with events: a form fill, a launch, a drop in performance. Agent systems built around events respond faster, and queues keep them safe.
The planner-executor pattern: separating what to do from doing it
Separating the agent that decides what to do from the agents that do it makes campaign automation easier to review, test, and trust.
Put this research to work
Marketix turns these patterns into software: agents, automated workflows, and a hub that keeps people in control. Sign up for early access.
