Which model should you use on QuickSilver Pro? A guide by job and budget

QuickSilver Pro has Claude Sonnet 5.5, Claude Haiku 5.5 and the rest of a large catalog behind one API key. Most people need two or three of them. This guide picks those for the common jobs, using only what we have measured ourselves: a 17-task benchmark run three times on seven models, twelve Claude Code runs per model on six coding tasks, and a small bug fix in OpenCode and Crush. All of it was run on 2026-10-20, and the details are in the posts linked from each section.

Where a recommendation rests on a number, the number is there. Where it is our judgement, it says so.

If you only read one thing

Measured costs are at QuickSilver Pro prices on 2026-10-20, computed from the tokens each request used.

What we measured

Three tests, all through the QuickSilver Pro API:

• 17-task benchmark. Seven Python coding tasks graded by unit tests, four extraction tasks graded by comparing the JSON with the expected object, six maths and logic questions with exact answers. One user message per task, max_tokens 8,000, default settings, three runs each, so 51 requests per model. Models: Claude Haiku 5.5, Sonnet 5.5 and Opus 5.5, DeepSeek V4.1 Flash (with and without reasoning), Kimi K3, GLM 5.3 and DeepSeek V4 Pro. Full write-ups: DeepSeek V4.1 Flash vs Claude Haiku 5.5 and open models vs Claude.
• Claude Code, Sonnet 5.5 vs Opus 5.5. Six small Python repositories (a two-file bug fix, a parser from a spec, a refactor, validation rules, a config parser, a Mustache renderer), each graded with hidden tests the agent never saw, two runs per model. Write-up: Opus 5.5 vs Sonnet 5.5 for coding.
• OpenCode and Crush. One easy one-line bug fix, one run per tool and model. Write-up: OpenCode and Crush with QuickSilver Pro.

The summary of the benchmark, for reference:

Costs at QuickSilver Pro prices on 2026-10-20. One task more or less moves a pass rate by two points, so treat 50 and 51 as the same result.

Coding agents

Use Claude Sonnet 5.5. In Claude Code it passed all hidden tests in all 12 runs across the six tasks, averaging 45 seconds and $0.069 per task, everything included. In the 17-task benchmark it passed 21 of 21 coding runs. Set it up with Claude Code on QuickSilver Pro, or in OpenCode and Crush.

For cheaper side calls, use a cheap model. Claude Code makes small background requests to whatever its haiku alias points at; map it to Claude Haiku 5.5. In Crush, set the small model to DeepSeek V4.1 Flash or Haiku; in our run it received one short request per session.

A cheap main model can handle easy fixes. In OpenCode, DeepSeek V4.1 Flash fixed our one-line bug for $0.0017, against $0.015 with Sonnet 5.5. That was one run on a deliberately easy bug, so it tells you the order of magnitude, not how Flash does on real work. We did not run DeepSeek V4.1 Flash, Haiku 5.5 or any open model on the six Claude Code tasks.

Open models for coding: our data says check first. In the single-prompt coding tasks, Kimi K3 passed 21 of 21 but took a median of 26.6 seconds per answer; GLM 5.3 passed 19 of 21; DeepSeek V4 Pro passed 15 of 21, mostly because it ran out of its 8,000-token limit while reasoning. None of them was tested inside an agent.

Extraction and classification at volume

Use Claude Haiku 5.5 when prompts are short. It got all 12 extraction runs right (invoice fields, attendees from meeting notes, log counts, an order's final state after a chat full of changes), at $0.13 per 1,000 tasks across the whole benchmark and a median of 2.8 seconds. Sonnet 5.5 also got all 12 right, for about 13 times the cost per task.

Things to know:

• We did not run a classification task. Extraction to JSON is the closest thing we measured. For labelling, we would expect the same ranking, but that is judgement, not data.
• Long prompts change the price. Haiku 5.5 bills a request at $0.125 / $0.625 when its prompt is longer than 200K tokens. DeepSeek V4.1 Flash keeps one rate across its 1M-token context. If you extract from long documents, compare the two prices for your sizes; we did not test long prompts.
• If you use DeepSeek V4.1 Flash for short jobs, turn reasoning off. Pass reasoning: {"enabled": false}. In our runs that cut its cost per task by two thirds ($0.97 to $0.32 per 1,000) and its median latency from 9.9 to 3.6 seconds, for 48 instead of 50 passes. It still got all 12 extraction runs right.
• Validate output either way. In one of 51 runs, GLM 5.3 wrote the right JSON and then appended its reasoning after it. To get JSON that follows a schema, see the JSON schema guide; on Claude models, use a tool with strict: true rather than json_schema strict mode.

Chat and assistants

Use Claude Haiku 5.5 for quick answers and Claude Sonnet 5.5 when the questions are harder. This one is judgement built on latency: their 90th-percentile response times in the benchmark were 7.2 and 7.0 seconds, and both passed all 18 of their maths and logic runs.

The data is thin here. Our tasks were single messages with checkable answers; we did not test multi-turn conversations, tone, long chat histories or languages other than English, and nothing in this guide measures writing quality.

What the data does rule out for interactive use is the slow reasoning models with default settings: Kimi K3's median was 26.6 seconds and its 90th percentile 140 seconds, DeepSeek V4 Pro's median 110 seconds. DeepSeek V4.1 Flash with reasoning on had a 40.5-second 90th percentile, against 9.0 with reasoning off. For streaming responses as they are generated, see streaming.

The cheapest possible

Claude Haiku 5.5 was the cheapest model per finished task in our benchmark: $0.13 per 1,000 tasks, against $0.32 for DeepSeek V4.1 Flash with reasoning off and $0.97 with it on. Two reasons: it is cheaper per token on both input and output, and it wrote fewer tokens (834 per answer on average, against 1,730 for Flash with reasoning on, most of which was reasoning).

Two caveats. Per-token price alone would have misled you: Flash's reasoning tokens are billed as output, so it cost seven times as much per task as Haiku despite its low list price. And Haiku's advantage shrinks or reverses on prompts above 200K tokens, which we did not test.

Both Haiku 5.5 and DeepSeek V4.1 Flash are starter models, so the $0.05 of free credit a new account gets is enough to run your own comparison on them. The free credit covers GPT-6 Luna, Claude Haiku 5.5, DeepSeek V4.1 Flash, Qwen3.8 Flash Next and MiMo-V2.6-Flash.

If you specifically want an open model, GLM 5.3 was the cheapest one that was also fast: 45 of 51 passed, 3.7-second median, $1.22 per 1,000 tasks — about 30% less than Sonnet 5.5 per task, with six more misses. Kimi K3 ($17.31) and DeepSeek V4 Pro ($5.68) both cost more per task than Sonnet 5.5 on this test.

When to pay for Opus

Rarely, on our evidence. We have not yet found a task where Opus 5.5 did better than Sonnet 5.5:

• In the 17-task benchmark both passed 51 of 51. Opus cost $3.80 per 1,000 tasks against $1.71, and its median latency was 5.2 seconds against 3.7.
• In Claude Code both passed every hidden test in all 12 runs. Opus cost $0.175 per task against $0.069 and took 72 seconds against 45 on average. Opus ran more shell commands to check its own work, such as fuzz-testing a refactor against the original, and each command also triggers one of Claude Code's own safety-check requests; those checks were more than half of the difference.

That is a statement about our tasks, not a ceiling on Opus: none of them was hard enough to make Sonnet fail, so they cannot show what Opus solves that Sonnet does not. Our judgement is to work in Sonnet and switch to Opus (/model opus in Claude Code) for the specific task where Sonnet keeps going round in circles, then switch back.

We have not benchmarked Claude Fable 5.1, so we make no recommendation about it here; its price is in Claude API pricing in 2026.

Switching is one word

Every model in this guide works through the same OpenAI-compatible endpoint, so routing jobs to different models is a matter of the model string:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.quicksilverpro.io/v1",
    api_key="YOUR_QSP_KEY",
)

MODEL_FOR = {
    "extract": "claude-haiku-5-5",
    "chat": "claude-haiku-5-5",
    "code": "claude-sonnet-5-5",
    "hard": "claude-opus-5-5",
}

response = client.chat.completions.create(
    model=MODEL_FOR["extract"],
    messages=[{"role": "user", "content": "Return the invoice number and total as JSON: ..."}],
)
print(response.choices[0].message.content)

The same works in LangChain and the Vercel AI SDK; see OpenAI SDK, LangChain and Vercel AI SDK on QuickSilver Pro. Every model ID is on the model list.

Limits of this guide

• The benchmark is 17 short, single-turn English tasks, three runs each. The Claude Code test is six small Python tasks, two runs each. The OpenCode and Crush test is one easy bug, one run per row.
• Not tested: long prompts, multi-turn chat, tool calling outside the coding agents, image input, other languages, open models inside a coding agent, Claude with extended thinking, open models with reasoning turned down (apart from DeepSeek V4.1 Flash), Claude Fable 5.1, and most of the catalog.
• Latency was measured from one client on one day.

Your own prompts are the test that counts. Every request shows up in your dashboard with its model, token counts and cost, so running a day of traffic through two models and comparing is straightforward.