Model guide

This is the master list. Every model Stella seeds into its catalog, with the numbers you need to make a decision — context window, list price, and what the model is actually good at. The pricing figures come from Stella's seed catalog; prices are list $/Mtok (input / output / cached-input). The Released and Best for columns are editorial — context these docs add, not fields the catalog stores or syncs. Verify with your provider before budgeting — prices and lineups drift.

The catalog

Which model for which role

Stella's pipeline runs three distinct roles, and they want different things from a model:

• Worker — writes the code. It wants the strongest coding model you can afford; this is where quality is bought. Worker tokens dominate a run, but most of them are cached-input tokens (see below), so the effective price gap between tiers is smaller than the list price suggests.
• Judge — verifies the work at high effort. It wants a different family than the worker: cross-family judging resists same-model bias, where a model forgives the mistakes it would itself have made. A Claude worker with a GPT judge (or vice versa) catches more than either family judging itself.
• Triage — classifies the task. It emits one token under a 10-second ceiling, so it wants the cheapest fast model you have a key for. Paying flagship prices here buys nothing.

Three named lineups, ready to copy:

Each links to a worked settings.json profile in Examples; wire any of them up per agent with agent_engine_config.

The live model catalog (stella models refresh)

The seed table above can't keep up with weekly model launches — and it used to mean an invalid slug was only caught for seeded providers (OpenRouter and custom gateways accepted anything and failed later, mid-run, on the wire). The live catalog fixes both:

stella models refresh                      # sync the master list (models.dev, no API key)
stella models list --provider anthropic    # browse valid slugs + live pricing

• Master list, locally. One public, unauthenticated document covering every provider Stella can select (plus ~160 more) lands in a user-tier SQLite catalog (catalog.db, next to usage.db): model cards keyed per API provider, and model card versions holding each pricing configuration. A refresh appends a new version only when pricing actually changed — the version history is real change history, and the latest version is the pricing that displays everywhere (cost metering, stella models list, the deck's model picker).
• Incremental. The HTTP ETag is persisted and replayed; an unchanged list is one conditional request, zero writes. After your first explicit refresh, Stella re-syncs a stale list (>24h) automatically at startup — never before your first refresh (the no-phone-home rule), and STELLA_CATALOG_AUTO_REFRESH=0 turns the re-sync off.
• Strict slug validation, everywhere. Once a provider's master-list rows are synced, an invalid --model slug is a hard, immediate, named error with did-you-mean suggestions — before any wire call, for every provider including OpenRouter and settings.json-defined gateways. The seed always passes, and a custom endpoint the master list doesn't know stays endpoint-authoritative, exactly as before.
• Exact telemetry. A model_aliases table joins every string form a model travels under — bare slug, provider/slug, date-stamped snapshots, region-prefixed Bedrock profiles, and any id a provider echoes on the wire (learned automatically from telemetry) — to (api provider, model provider, model version, model card), so per-model cost analytics never split one model across its spellings.

Prompt caching changes the math

The cached-input column is what most worker input actually costs mid-run. Stella keeps the prompt prefix byte-stable on purpose — the context engine appends rather than rewrites — so after the first turn, the bulk of every request is a cache hit billed at the cached-input rate: a 10x–20x discount depending on provider. This is why real per-run cost lands far below naive input-tokens-times-list-price math, and why a model's cached-input price matters more than its headline input price for long agentic runs.