Skip to main content
GSD Core assigns a model tier to each of its specialized agents based on the active model profile. Rather than running every agent on the most expensive model, profiles let you allocate compute intentionally — Opus for the agents where reasoning quality drives the outcome, Sonnet for workhorses, and Haiku for fast scanners and mappers. Dynamic routing and effort control let you push that further: start cheap and escalate only when an agent fails its quality gate.

​
Built-in profiles

Set model_profile in config.json or switch profiles instantly with /gsd-config --profile <name>.
Uses Opus for all decision-making agents and Sonnet for verification. Best for quota-rich environments and critical architecture work where output quality is the top priority.

​
Agent tier assignments

The table below shows how the five most-used agents resolve under each profile. The tier names (Opus, Sonnet, Haiku) are resolved to runtime-native model IDs when runtime is set in config.json.
Agentqualitybalancedbudgetadaptiveinherit
gsd-plannerOpusOpusSonnetOpusInherit
gsd-executorOpusSonnetSonnetSonnetInherit
gsd-phase-researcherOpusSonnetHaikuSonnetInherit
gsd-verifierSonnetSonnetHaikuSonnetInherit
gsd-codebase-mapperSonnetHaikuHaikuHaikuInherit
The full catalog covers all 33 shipped agents with explicit per-profile tier assignments. These five represent the most frequently invoked agents during a standard phase lifecycle.

​
Per-agent overrides

Override individual agents without changing the profile for everything else. This is useful when you want one agent to use a more powerful model than the profile assigns. 
{
  "model_profile": "balanced",
  "model_overrides": {
    "gsd-executor": "opus",
    "gsd-codebase-mapper": "haiku"
  }
}
Valid override values: opus, sonnet, haiku, inherit, or a fully-qualified model ID such as "openai/o3" or "google/gemini-2.5-pro".

​
Per-phase-type model assignment

The models block lets you tune at the phase level without knowing individual agent names. Specify a tier for each phase type and GSD applies it to all agents in that category. 
{
  "model_profile": "balanced",
  "models": {
    "planning": "opus",
    "research": "sonnet",
    "execution": "opus",
    "verification": "sonnet"
  }
}
Phase typeAgents included
planninggsd-planner, gsd-roadmapper, gsd-pattern-mapper
researchgsd-phase-researcher, gsd-project-researcher, gsd-codebase-mapper, gsd-ui-researcher
executiongsd-executor, gsd-debugger, gsd-doc-writer
verificationgsd-verifier, gsd-plan-checker, gsd-nyquist-auditor, gsd-ui-checker
Resolution precedence (highest to lowest):
  1. model_overrides[<agent>] — per-agent exception, wins over everything
  2. dynamic_routing.tier_models[<tier>] — when dynamic routing is enabled
  3. models[<phase_type>] — coarse phase-level tier
  4. model_profile — global profile tier per agent
  5. Runtime default

​
Dynamic routing with failure-tier escalation

Dynamic routing lets agents start on a cheaper tier and escalate automatically when the orchestrator detects a soft failure (plan-check FLAG, verification inconclusive). Enable it with dynamic_routing.enabled: true. 
{
  "dynamic_routing": {
    "enabled": true,
    "tier_models": {
      "light":    "haiku",
      "standard": "sonnet",
      "heavy":    "opus"
    },
    "escalate_on_failure": true,
    "max_escalations": 1
  }
}
Each agent is pre-assigned to one of three default tiers based on its role:
TierExamplesUse case
lightgsd-codebase-mapper, gsd-nyquist-auditor, gsd-plan-checkerFast mappers, scanners, low-stakes audits
standardgsd-executor, gsd-verifier, gsd-phase-researcherDefault workhorse agents
heavygsd-planner, gsd-roadmapper, gsd-debuggerDeep reasoning — these agents are already at the top tier
KeyTypeDefaultDescription
dynamic_routing.enabledbooleanfalseMaster switch. true activates the dynamic resolver.
dynamic_routing.tier_models.lighttier alias(none)Model for the light tier, typically haiku.
dynamic_routing.tier_models.standardtier alias(none)Model for the standard tier, typically sonnet.
dynamic_routing.tier_models.heavytier alias(none)Model for the heavy tier, typically opus.
dynamic_routing.escalate_on_failurebooleantrueWhen false, every attempt uses the default tier regardless of failure.
dynamic_routing.max_escalationsinteger1Hard cap on retry escalations per agent invocation.

​
Effort control

Control the reasoning effort of each agent invocation independently of model tier. The universal effort ladder is: 
minimal < low < medium < high < xhigh < max
Effort is rendered per-runtime: output_config.effort for Claude, model_reasoning_effort for Codex. Cross-provider clamping applies: max is Anthropic-only and clamps to xhigh on Codex; minimal is Codex-only and clamps to low on Claude. 
{
  "effort": {
    "default": "high",
    "routing_tier_defaults": {
      "light":    "low",
      "standard": "high",
      "heavy":    "xhigh"
    },
    "agent_overrides": {
      "gsd-planner": "max"
    }
  }
}
KeyDefaultDescription
effort.default"high"Global fallback effort level when no tier or agent override matches.
effort.routing_tier_defaults.light"low"Effort for light-tier agents.
effort.routing_tier_defaults.standard"high"Effort for standard-tier agents.
effort.routing_tier_defaults.heavy"xhigh"Effort for heavy-tier agents.
effort.agent_overrides.<agent-id>(none)Per-agent effort override; beats all tier defaults.
Effort precedence (highest to lowest):
  1. Invocation override (e.g. --effort flag on resolve-execution)
  2. effort.agent_overrides[<agent-id>]
  3. effort.routing_tier_defaults[<light|standard|heavy>]
  4. effort.default
  5. "high" (universal default)

​
Profile philosophy

ProfilePhilosophyWhen to use
qualityOpus for all decision-making, Sonnet for verificationQuota available; critical architecture work
balancedOpus for planning only, Sonnet for everything elseNormal development (recommended default)
budgetSonnet for code-writing, Haiku for research/verificationHigh-volume work, less critical phases
inheritAll agents follow the session modelNon-Anthropic providers, OpenRouter, local models