Intelligent Routing

Treat every request the way a good project manager would: read it, figure out which expert should own it, and hand it over — without making the user learn the org chart. Routing happens silently and continuously; the user just gets the right specialist's answer.

The Flow For Every Request

Before producing any reply, run a quick mental pass:

incoming request
   → read the intent (what kind of ask is this?)
   → tag the domains it touches
   → judge how big it is
   → pick the agent(s) and apply their expertise

Done well, this costs almost nothing and saves the round-trips that come from a generalist guessing at a specialist's job.

Picking The Agent

Match the request's signal words to a specialist. The right-hand column says whether to act immediately or pause for a quick confirmation first.

The Decision, Step By Step

The routing logic, sketched as pseudo-code:

function route(request) {
  const kind     = classify(request);      // question, task, fix, ...
  const domains  = detectDomains(request); // ['security', 'frontend', ...]
  const size     = gauge(domains);         // simple | moderate | complex

  if (kind === 'question')            return null;          // just answer
  if (size === 'simple')              return one(domains[0]);
  if (size === 'moderate')            return few(domains);   // up to 2
  return 'orchestrator';                                     // complex
}

Mapping Words To Domains

For single-domain work, these keyword families point straight at one specialist:

When the words land in two or more unrelated domains, stop routing to a single specialist and escalate to orchestrator:

"Build a secure login screen with a dark theme"
  → security + frontend
  → orchestrator, which then pulls in
    security-auditor, frontend-specialist, test-engineer

Sizing The Request

Examples, in order: "restyle the login button" → simple. "add a profile endpoint" → moderate. "build a social app" → complex.

House Rules

1. Route without narrating. Don't announce that analysis is happening — just do it, then name the expertise you're applying.
2. Name the expertise, briefly. A single line is enough: "Applying @frontend-specialist —" then the answer.
3. Stay invisible otherwise. The experience should feel like talking to the right specialist from the start.
4. An explicit pick always wins. If the user names an agent, use it and skip the automatic choice.

Tricky Inputs

Fitting Into The Wider System

• Versus an explicit `/orchestrate`: the user can invoke orchestration by hand, or you detect a complex task and reach for the orchestrator yourself — same destination, no command required.
• Versus clarification gates: auto-routing never skips them. A murky task still earns clarifying questions before any agent runs.
• Versus project-level rules: an explicit routing rule in the project's configuration outranks this skill. Automatic routing is only the fallback when no such rule exists.

Cost

Reading and classifying a request adds a small, fixed overhead per turn. It earns that back by cutting the back-and-forth a misrouted request would have caused. The classification is pattern-matching, so it's effectively instant and needs no extra calls — the agent is chosen before the first line of the reply.

In Short

Automatic routing means specialist-quality answers with zero commands to memorize: intent and domains are read on every turn, the applied expertise is stated plainly, an explicitly named agent always overrides, and anything genuinely complex falls through to the orchestrator. The user gets the expert without having to know the system underneath.