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

> Explore gsd-build model profiles: Quality, Balanced, and Budget. Optimize Claude model usage, balancing reasoning depth against token costs for your AI projects.

- Repository: [GSD/get-shit-done](https://github.com/gsd-build/get-shit-done)
- Tags: guide
- Published: 2026-02-16

---

**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`](https://github.com/gsd-build/get-shit-done/blob/main/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`](https://github.com/gsd-build/get-shit-done/blob/main/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`](https://github.com/gsd-build/get-shit-done/blob/main/get-shit-done/references/model-profile-resolution.md), follows this sequence:

1. **Read configuration**: The system loads [`.planning/config.json`](https://github.com/gsd-build/get-shit-done/blob/main/.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`](https://github.com/gsd-build/get-shit-done/blob/main/get-shit-done/workflows/set-profile.md):

```bash
/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`](https://github.com/gsd-build/get-shit-done/blob/main/.planning/config.json) in your project root:

```json
{
  "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`](https://github.com/gsd-build/get-shit-done/blob/main/.planning/config.json) to specify exact models for individual agents while keeping the overall profile:

```json
{
  "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`](https://github.com/gsd-build/get-shit-done/blob/main/.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`](https://github.com/gsd-build/get-shit-done/blob/main/.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`](https://github.com/gsd-build/get-shit-done/blob/main/.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`](https://github.com/gsd-build/get-shit-done/blob/main/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.