GSD-Build Model Profiles: Quality, Balanced, and Budget Token Usage Guide

GSD-Build provides three model profiles—quality, balanced, and budget—that map specialized agents to Claude's Opus, Sonnet, or Haiku models, allowing you to trade off reasoning depth against token consumption and API costs.

GSD-Build is an open-source AI coding framework that orchestrates multiple specialized agents to complete complex software development tasks. Understanding the model profiles in gsd-build is essential for controlling costs while maintaining output quality, as each profile determines which Claude model tier every agent invokes during execution.

The Three GSD-Build Model Profiles

According to get-shit-done/references/model-profiles.md, GSD-Build defines three distinct profiles that determine agent-to-model mappings.

Quality Profile (Maximum Reasoning Power)

The quality profile prioritizes maximum reasoning capability by routing nearly all agents to Claude's most powerful model. This profile maps:

• gsd-planner, gsd-roadmapper, gsd-executor, gsd-phase-researcher, gsd-project-researcher, and gsd-debugger → opus
• gsd-research-synthesizer, gsd-codebase-mapper, gsd-verifier, gsd-plan-checker, and gsd-integration-checker → sonnet

Use this profile when quota is plentiful or the work is critical, as it consumes the most tokens per request.

Balanced Profile (Default Smart Allocation)

The balanced profile is the default configuration that intelligently distributes agents across model tiers to optimize the quality-to-cost ratio. As defined in the source documentation:

• gsd-planner → opus (retains high-level architectural reasoning)
• gsd-roadmapper, gsd-executor, gsd-phase-researcher, gsd-project-researcher, gsd-research-synthesizer, gsd-debugger, gsd-verifier, gsd-plan-checker, and gsd-integration-checker → sonnet
• gsd-codebase-mapper → haiku (suitable for high-volume code analysis)

This profile represents the recommended starting point for normal development workflows.

Budget Profile (Minimal Token Usage)

The budget profile minimizes Opus usage to reduce token consumption for high-volume or low-risk work. The mapping shifts most agents to lighter models:

• gsd-planner, gsd-roadmapper, gsd-executor, and gsd-debugger → sonnet
• gsd-phase-researcher, gsd-project-researcher, gsd-research-synthesizer, gsd-codebase-mapper, gsd-verifier, gsd-plan-checker, and gsd-integration-checker → haiku

This configuration significantly reduces API costs while maintaining adequate performance for routine tasks.

Token Usage Implications by Model Tier

Each model profile directly impacts token consumption because Claude's API pricing scales with model capability. The three tiers used in GSD-Build have distinct cost characteristics:

Model Tier	Token Cost Level	Typical Impact
opus	High	Provides the best reasoning and architectural decision-making but consumes the most tokens per request. Reserved for critical planning and debugging tasks.
sonnet	Medium	Offers a strong balance of quality and cost. Default choice for most agents across all profiles, suitable for general execution and research synthesis.
haiku	Low	Minimizes token spend for high-volume operations like codebase mapping and verification. Ideal for tasks requiring speed over deep reasoning.

According to the source documentation in get-shit-done/references/model-profiles.md, exact token pricing follows Claude's public API rates; GSD-Build only selects the appropriate tier.

How Model Profile Resolution Works

GSD-Build implements a specific resolution chain to determine which model each agent uses at runtime. The logic, documented in get-shit-done/references/model-profile-resolution.md, follows this sequence:

1. Read configuration: The system loads .planning/config.json from the project root.
2. Apply overrides: If model_overrides are defined for specific agents, these take immediate precedence.
3. Profile lookup: If no override exists, the system looks up the agent in the selected profile's mapping table.
4. Task execution: The resolved model name is passed to the task runner, which invokes the Claude API.

This resolution mechanism allows granular control—you can switch entire profiles for broad cost management or override individual agents for specific needs.

Configuring Model Profiles in Your Project

You can configure model profiles through CLI commands, project configuration files, or per-agent overrides.

Switch Profile at Runtime

Use the CLI command documented in get-shit-done/workflows/set-profile.md:

/gsd:set-profile budget

This updates the in-memory setting and displays a confirmation table showing the new agent-to-model mappings.

Set a Default Profile Per-Project

Create or edit .planning/config.json in your project root:

{
  "model_profile": "balanced"
}

When the project runs, GSD-Build reads this file and resolves agents according to the balanced profile table.

Override Specific Agents

You can define model_overrides in your .planning/config.json to specify exact models for individual agents while keeping the overall profile:

{
  "model_profile": "balanced",
  "model_overrides": {
    "gsd-executor": "opus",
    "gsd-codebase-mapper": "haiku"
  }
}

These overrides take precedence over the profile mapping, allowing you to allocate more reasoning power to critical agents or reduce costs for high-volume tasks.

Summary

• GSD-Build offers three model profiles—quality, balanced, and budget—that map internal agents to Claude's Opus, Sonnet, or Haiku models.
• Quality maximizes reasoning by routing most agents to Opus, consuming the most tokens.
• Balanced (the default) intelligently distributes agents across all three model tiers for optimal cost-quality trade-offs.
• Budget minimizes Opus usage, shifting most agents to Sonnet or Haiku for high-volume, low-risk work.
• Configuration occurs via .planning/config.json or the /gsd:set-profile CLI command, with optional per-agent overrides for granular control.

Frequently Asked Questions

What is the default model profile in GSD-Build?

The balanced profile is the default configuration. It provides intelligent allocation of agents across Claude's Opus, Sonnet, and Haiku models to optimize the trade-off between reasoning quality and token consumption for typical development workflows.

How do I reduce token costs when using GSD-Build?

Switch to the budget profile using the CLI command /gsd:set-profile budget or set "model_profile": "budget" in your .planning/config.json. This profile routes most agents to Sonnet or Haiku instead of Opus, significantly reducing token usage while maintaining adequate performance for routine tasks.

Can I use different models for specific agents only?

Yes. You can define model_overrides in your .planning/config.json to specify exact models for individual agents while keeping the overall profile. For example, you can force gsd-executor to use opus for critical execution tasks while keeping other agents on lighter models, as documented in get-shit-done/references/model-profiles.md.

Which agents always use Opus regardless of profile?

No agents use Opus in all three profiles. However, certain agents like gsd-planner use Opus in both the quality and balanced profiles, only dropping to Sonnet in the budget profile. The gsd-codebase-mapper consistently uses lighter models (Sonnet in quality, Haiku in balanced and budget) due to its high-volume nature.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}