Model Profiles
A model profile decides which model tier each agent in PP Core uses. Profiles let you trade cost against reasoning quality with a single setting, while routing tiers and effort levels give you finer control when you need it.
The Five Profiles
Set the active profile with the model_profile key (see the Settings page). Each profile is a preset mapping from agents to model tiers:
| Profile | Strategy |
|---|---|
quality | Opus for every decision-making agent, Sonnet for verification. |
balanced | Opus for planning agents only, Sonnet for everything else. This is the default. |
budget | Sonnet for code-writing, Haiku for research and verification. |
adaptive | Biases toward Opus wherever reasoning quality matters most. |
inherit | Every agent runs on whatever model the current session is using. |
Tier Assignments by Agent
The five primary agents resolve to the following tiers under each profile:
| Agent | quality | balanced | budget | adaptive | inherit |
|---|---|---|---|---|---|
| planner | Opus | Opus | Sonnet | Opus | inherit |
| executor | Opus | Sonnet | Sonnet | Sonnet | inherit |
| phase-researcher | Opus | Sonnet | Haiku | Sonnet | inherit |
| verifier | Sonnet | Sonnet | Haiku | Sonnet | inherit |
| codebase-mapper | Sonnet | Haiku | Haiku | Haiku | inherit |
If you find yourself paying for Opus on work that does not need it, budget is the quickest lever. If a project is high-stakes and cost is secondary, quality keeps the strongest model on the reasoning-heavy steps.
Routing by Task Type
Agents are grouped into phase-type categories so the engine can reason about them collectively:
- planning — planner, roadmapper, pattern-mapper
- research — phase-researcher, project-researcher, codebase-mapper, ui-researcher
- execution — executor, debugger, doc-writer
- verification — verifier, plan-checker, nyquist-auditor, ui-checker
On top of categories, PP Core sorts agents into three dynamic routing tiers based on how much thinking they do:
- light — fast scanners and mappers, such as the codebase-mapper and nyquist-auditor.
- standard — the workhorses that do most of the building and checking, such as the executor and verifier.
- heavy — deep-reasoning agents, such as the planner and debugger.
Reasoning Effort Levels
Effort levels control how hard a model thinks before answering. They follow a single universal ladder, from cheapest and fastest to most thorough:
minimal < low < medium < high < xhigh < max
Each routing tier carries a default effort so that light work stays fast and heavy work gets room to reason:
| Routing tier | Default effort |
|---|---|
| light | low |
| standard | high |
| heavy | xhigh |
| global fallback | high |
Resolution Order
When PP Core needs to pick a model and effort for a given agent, it checks these sources in order and uses the first match:
- Per-agent overrides in
model_overrides. - Dynamic routing tier assignments.
- Phase-type assignments in the
modelssection. - The active
model_profile. - The runtime default.
This layering means you can adopt a profile as your baseline and then override a single agent without disturbing anything else.
Providers and Budget
Model policy is expressed against a set of providers — anthropic, anthropic-fable, google, openai, qwen, and generic — so the same profile can resolve to the right model regardless of which runtime is active. A coarse budget dial with high, medium, and low settings gives you an overall spend posture that the routing tiers respect.
Example
A configuration that keeps the default profile but forces the planner to maximum effort:
{
"model_profile": "balanced",
"model_overrides": {
"planner": { "effort": "max" }
}
}