SwitchBoard

Other

Cost-optimize AI agent operations by routing tasks to appropriate models based on complexity. Use this skill when: (1) deciding which model to use for a task, (2) spawning sub-agents, (3) considering cost efficiency, (4) the current model feels like overkill for the task. Triggers: "model routing", "cost optimization", "which model", "too expensive", "spawn agent", "cheap model", "expensive", "tier 1", "tier 2", "tier 3".

Install

openclaw skills install router

SwitchBoard

Route tasks to the cheapest model that can handle them. Most agent work is routine.

Prerequisites

This skill requires an OpenRouter API key for model routing. Add it to your OpenClaw user config:

// ~/.openclaw/openclaw.json
{
  "openrouter_api_key": "sk-or-v1-..."
}

Without this key, /model switching and sessions_spawn with non-default models will fail. Get a key at openrouter.ai/keys.

Privacy Note: Some models listed in this skill (e.g., Aurora Alpha, Free Router) may log prompts and completions for provider training. Do not route sensitive data (API keys, passwords, private PII) through free or unmoderated models. Review model privacy policies at openrouter.ai/docs before use.

Core Principle

80% of agent tasks are janitorial. File reads, status checks, formatting, simple Q&A. These don't need expensive models. Reserve premium models for problems that actually require deep reasoning.

Model Tiers

For OpenRouter-specific pricing and models, see references/openrouter-models.md.

Tier 0: Free

Model	Context	Tools	Best For
Aurora Alpha	128K	✅	Zero-cost reasoning, cloaked community model
Free Router	200K	✅	Auto-routes to best available free model
Step 3.5 Flash (free)	256K	✅	Long-context reasoning at zero cost

Free models have rate limits and variable availability. Good for non-critical background tasks.

Tier 1: Cheap ($0.02-0.50/M tokens)

Model	Input	Output	Context	Tools	Best For
Qwen3 Coder Next	$0.07	$0.30	262K	✅	Agentic coding, MoE 80B/3B active
Gemini 2.0 Flash Lite	$0.07	$0.30	1M	✅	High volume, massive context
Gemini 2.0 Flash	$0.10	$0.40	1M	✅	General routine with long context
GPT-4o-mini	$0.15	$0.60	128K	✅	Quick responses, reliable tool use
DeepSeek Chat	$0.30	$1.20	164K	✅	General routine work
Claude 3 Haiku	$0.25	$1.25	200K	✅	Fast tool use, structured output
Kimi K2.5	$0.45	$2.20	262K	✅	Multimodal, visual coding, agentic

Tier 2: Mid ($1-5/M tokens)

Model	Input	Output	Context	Tools	Best For
o3-mini	$1.10	$4.40	200K	✅	Reasoning on a budget
Gemini 2.5 Pro	$1.25	$10.00	1M	✅	Long context, large codebase work
GPT-4o	$2.50	$10.00	128K	✅	Multimodal tasks
Claude Sonnet	$3.00	$15.00	1M	✅	Balanced performance, agentic

Tier 3: Premium ($5+/M tokens)

Model	Input	Output	Context	Tools	Best For
Claude Opus 4.6	$5.00	$25.00	1M	✅	Complex reasoning, deep context
o1	$15.00	$60.00	200K	✅	Multi-step reasoning
GPT-4.5	$75.00	$150.00	128K	✅	Frontier tasks

Prices as of Feb 2026. Check provider docs for current rates. Context = max context window. Tools = function calling support.

Task Classification

Before executing any task, classify it:

ROUTINE → Use Tier 1

Characteristics:

Single-step operations
Clear, unambiguous instructions
No judgment required
Deterministic output expected

Examples:

File read/write operations
Status checks and health monitoring
Simple lookups (time, weather, definitions)
Formatting and restructuring text
List operations (filter, sort, transform)
API calls with known parameters
Heartbeat and cron tasks
URL fetching and basic parsing

MODERATE → Use Tier 2

Characteristics:

Multi-step but well-defined
Some synthesis required
Standard patterns apply
Quality matters but isn't critical

Examples:

Code generation (standard patterns)
Summarization and synthesis
Draft writing (emails, docs, messages)
Data analysis and transformation
Multi-file operations
Tool orchestration
Code review (non-security)
Search and research tasks

COMPLEX → Use Tier 3

Characteristics:

Novel problem solving required
Multiple valid approaches
Nuanced judgment calls
High stakes or irreversible
Previous attempts failed

Examples:

Multi-step debugging
Architecture and design decisions
Security-sensitive code review
Tasks where cheaper model already failed
Ambiguous requirements needing interpretation
Long-context reasoning (>50K tokens)
Creative work requiring originality
Adversarial or edge-case handling

Decision Algorithm

function selectModel(task):
  # Rule 1: Escalation override
  if task.previousAttemptFailed:
    return nextTierUp(task.previousModel)

  # Rule 2: Hard constraints (filter before cost)
  candidates = ALL_MODELS
  if task.requiresToolUse:
    candidates = candidates.filter(m => m.supportsTools)
  if task.estimatedTokens > 128_000:
    candidates = candidates.filter(m => m.contextWindow >= task.estimatedTokens)
  if task.requiresMultimodal:
    candidates = candidates.filter(m => m.supportsImages)

  # Rule 3: Latency constraint
  if task.isRealTime or task.inAgentLoop:
    candidates = candidates.filter(m => m.latencyTier <= "fast")

  # Rule 4: Complexity classification
  if task.hasSignal("debug", "architect", "design", "security"):
    return cheapestIn(candidates, TIER_3)
  if task.hasSignal("summarize", "analyze", "refactor"):
    return cheapestIn(candidates, TIER_2)

  complexity = classifyTask(task)
  if complexity == ROUTINE:
    return cheapestIn(candidates, TIER_1)
  elif complexity == MODERATE:
    return cheapestIn(candidates, TIER_2)
  else:
    return cheapestIn(candidates, TIER_3)

Note: "write", "read", "code" alone are poor routing signals — "write a file" is Tier 1: work, not Tier 2. Classify based on the task structure, not individual keywords.

Latency Considerations

Cost isn't the only axis. For real-time agent loops, latency matters:

Tier	Typical TTFT	Throughput	Use When
Free	1-5s	Variable	Background tasks, not time-sensitive
Tier 1	200-800ms	50-100 tok/s	Agent loops, real-time pipelines
Tier 2	500ms-2s	30-80 tok/s	Interactive sessions, async work
Tier 3	1-10s	10-40 tok/s	One-shot complex tasks, async only

TTFT = Time To First Token. Reasoning models (o1, o3-mini) have high TTFT due to thinking time but are worth it for hard problems.

Rule of thumb: If the agent is waiting in a loop for a response before the next action, use Tier 1. If the task is fire-and-forget, cost matters more than speed.

Behavioral Rules

For Main Session

Default to Tier 2 for interactive work
Suggest downgrade when doing routine work: "This is routine - I can handle this on a cheaper model or spawn a sub-agent."
Request upgrade when stuck: "This needs more reasoning power. Switching to [premium model]."

For Sub-Agents

Default to Tier 1 unless task is clearly moderate+
Batch similar tasks to amortize overhead
Report failures back to parent for escalation
Check context window limits before dispatching — don't send 200K tokens to a 32K model

For Automated Tasks

Heartbeats/monitoring → Always Tier 1 (or Free if available)
Scheduled reports → Tier 1 or 2 based on complexity
Alert responses → Start Tier 2, escalate if needed
Background data fetching → Free tier when non-critical

Communication Patterns

When suggesting model changes, use clear language:

Downgrade suggestion:

"This looks like routine file work. Want me to spawn a sub-agent on DeepSeek for this? Same result, fraction of the cost."

Upgrade request:

"I'm hitting the limits of what I can figure out here. This needs Opus-level reasoning. Switching up."

Explaining hierarchy:

"I'm running the heavy analysis on Sonnet while sub-agents fetch the data on DeepSeek. Keeps costs down without sacrificing quality where it matters."

Cost Impact

Assuming 100K tokens/day average usage:

Strategy	Monthly Cost	Notes
Pure Opus 4.6	~$75	Maximum capability, lower than old Opus
Pure Sonnet	~$45	Good default for most work
Pure DeepSeek	~$9	Cheap but limited on hard problems
Pure Qwen3 Coder	~$2	Cheapest viable for coding agents
Hierarchy (80/15/5)	~$12	Best of all worlds
With Free tier (85/10/4/1)	~$8	Aggressive optimization

The 80/15/5 split:

80% routine tasks on Tier 1 (~$4)
15% moderate tasks on Tier 2 (~$5)
5% complex tasks on Tier 3 (~$3)

Result: 6-10x cost reduction vs pure premium, with equivalent quality on complex tasks.

OpenClaw Integration

Session Model Switching

# config.yml - set your default session model
model: anthropic/claude-sonnet-4

# Mid-session, switch down for routine work
/model deepseek/deepseek-chat

# Switch up when you hit a wall
/model anthropic/claude-opus-4

Spawning Sub-Agents

# Batch routine tasks on cheap models
sessions_spawn:
  task: "Fetch and parse these 50 URLs"
  model: deepseek/deepseek-chat

# Use Qwen3 Coder for file-heavy agent work
sessions_spawn:
  task: "Refactor these test files to use the new helper"
  model: qwen/qwen3-coder-next

# Free tier for non-critical background jobs
sessions_spawn:
  task: "Check health of all endpoints and log status"
  model: openrouter/free

Recommended OpenClaw Defaults

Task Type	Model	Why
Main interactive session	`claude-sonnet-4`	Best balance of quality and cost
File ops, fetches, formatting	`deepseek/deepseek-chat`	Cheap, reliable
Agentic coding sub-tasks	`qwen/qwen3-coder-next`	$0.07/M, 262K context, tool use
Background monitoring	`openrouter/free`	Zero cost
Stuck / complex debugging	`anthropic/claude-opus-4`	Escalate only when needed

Anti-Patterns

DON'T:

Leave your session on Opus when the task is clearly routine — /model deepseek exists for a reason
Spawn sub-agents without specifying a model — they inherit the session model, which is usually Tier 2
Use Tier 3 for sessions_spawn tasks like file parsing, URL fetching, or status checks
Forget context window limits — spawning a 200K-token task on a 32K model will silently truncate
Run recurring or scheduled tasks on anything above Tier 1

DO:

Set model: anthropic/claude-sonnet-4 as your config.yml default — good baseline
Always set an explicit model field in sessions_spawn — default to deepseek/deepseek-chat or qwen/qwen3-coder-next
/model switch down the moment you realize the current task is janitorial
/model switch up the moment you're stuck — don't waste tokens retrying on a weak model
Use openrouter/free for fire-and-forget background checks

Extending This Skill

Optimize your switchboard over time:

Track your actual spend — review your OpenRouter dashboard weekly to see which models are burning tokens
Add your own routing signals — if your workflow has domain terms (e.g., "settlement", "pricing", "vault"), map them to tiers
Tune the 80/15/5 split — if you find yourself escalating more than 5% of tasks, your classification may be too aggressive
Pin model versions — when a cheap model works well for you, pin the version (e.g., deepseek/deepseek-chat-v3.1) so provider updates don't break your flow
Set OpenRouter budget alerts — catch runaway premium usage before it compounds