I was not paying too much for AI. I was paying for the wrong model.
The price was never the problem. I pay a fixed amount each month and then spend it model by model, often on the wrong one. A cheap model can carry a full day of work; an expensive one empties the same window in an afternoon. ZenPick puts OpenCode Go, Zed Pro and GitHub Copilot Pro models on one table, shows what each plan charges, and builds a main agent plus a cheaper sub-agent, so the budget you already pay for goes further.
Built by Michael Open source · Free to use
What ZenPick does
One table covers OpenCode Go, Zed Pro and GitHub Copilot Pro. Filter to one plan and every price is that plan's price. Leave it on all plans and each row shows the cheapest input rate plus the plans that carry the model.
The agent stack picks a main agent and a cheaper sub-agent. It shows what the pair costs per
100 requests, how much that saves against sending everything to the main model, and how many
requests the monthly allowance covers. In /compare,
picks are plan:id keys, so one selection can hold models
from different plans.
OpenCode Go keeps the tools that depend on its request windows: the quota calculator, thermal burn bands and the burn chart. Zed Pro and Copilot Pro use monthly token allowances, so their rows carry plan prices, intelligence, coding score and context instead.
Everything runs on a stale-while-revalidate cache, so revisits are instant and live data is not fetched again within six hours. A build that ran without upstream data expires after 15 minutes instead of holding nulls for six hours.
Three plans, one table
All three plans cost $10 a month. What differs is what the $10 buys: request windows on OpenCode Go, a token credit on Zed Pro and GitHub Copilot Pro. The cards read the same plan data as the app, so this page cannot drift from the table.
Main agent, cheaper sub-agent
The main agent plans, decides and writes the hard parts. Sub-agents implement, review and fix. Send most requests to a cheaper model and the same allowance stretches further.
Nothing joins your comparison until you press Compare this pair. The link
carries both keys (?models=plan:id,plan:id), so it
reopens the pair on the compare page and you can add more models there.
The numbers
OpenCode Go, Zed Pro and GitHub Copilot Pro each cost the same.
Loading…
Loading…
Stale-while-revalidate; 15 minutes when an upstream build is partial.
No account, no paywall, open source.
OpenCode Go only. Burn bands come from its published request windows; Zed Pro and Copilot Pro use monthly token credits.
Every model is one dot. The shaded corner is the sweet spot — scoring above the median while costing less than it — and the ringed dot is the strongest model in there. Zed Pro and Copilot Pro rows are not plotted because they have no burn band.
Methodology
OpenCode Go models get a 0 to 100 fit score for five scenarios: Brainstorming, Coding, Agentic, Budget, and Frontend. Scores are normalized across the current Go population, so the ordering is always meaningful and always non-empty. The table sorts by the active scenario; with none active, it sorts by raw coding benchmark.
Zed Pro and Copilot Pro rows skip the scenario score. They show the plan's price, Artificial Analysis intelligence, coding score and context window instead. Scenario filters clear when you switch to those plans, so a ranking never hides models the data cannot score.
Coding prefers the published DeepSWE 1.1 dataset from llm-stats when the
model has it. Without that row it falls back to modelgrep's Artificial Analysis coding
index, then the other labelled fallbacks. Only the coarse llm-stats code category score carries an est. tag, because that one is a rounded estimate rather than
a measured benchmark.
Gamefeel is its own benchmark: 12 unpublished games, scored on coding create, coding bugfix, gamefeel and creativity. It gets its own column and its own compare rows, and it is never blended into Coding. A dash means the benchmark has no scored row for that model, not that it scored zero.
Go tags and thermal burn rates are inferred from upstream data. Migration hints compare blended benchmarks against closed-source models from LLM Stats when it is available, plus the current Zed Pro and Copilot Pro pages. Plan facts are different: prices, allowances, caveats and model lists are hand-checked against the vendor pages, and every card carries the date it was checked. If an upstream value changes, the page changes; if a vendor page changes, the plan card waits for a code update.
OpenCode Go only. The radar runs on scenario fit scores, which the static plans do not have.
Data & attribution
Benchmark scores, pricing, and speed data are aggregated by modelgrep.com (OpenRouter pricing + Artificial Analysis benchmarks) and llm-stats.com (benchmark scores, rankings, and pricing), and used with attribution. The OpenCode Go catalog comes from its docs and models.dev. Zed Pro and Copilot Pro plan facts come from the vendor pages in the table below.
Gamefeel scores come from the Gamefeel Benchmark v1.4 and are shown with the date they were fetched. The benchmark is game-development specific, so it is never blended into the general Coding score.
Everything ZenPick computes on top (scenario fit scores, burn rate tiers, migration hints) is derived from those sources, in the schematic above. Plan facts are hand-checked, not inferred. The data and the attribution are kept close on purpose.
| Provider | License | Use in ZenPick |
|---|---|---|
| modelgrep.com attribution required | Free public API (no key required) | Benchmark scores, OpenRouter pricing, speed/latency, model metadata |
| llm-stats.com attribution required | Per LLM Stats API terms | Benchmark scores, rankings, pricing, model metadata |
| Gamefeel Benchmark attribution required | Published data, credited with a link | Gamefeel v1.4 game-development scores and price per task |
| opencode.ai/v2/docs/console/go | Per OpenCode Go docs | Model list, endpoint types, quota windows |
| models.dev | Open source (MIT) | First-party OpenCode catalog metadata and the Go model lifecycle history |
| zed.dev · hosted models | Per Zed docs | Zed Pro model list and list prices |
| zed.dev · plans & pricing | Per Zed docs | Zed Pro monthly price, included token credit and 10% markup |
| GitHub · supported models | Per GitHub docs | Copilot Pro model list |
| GitHub · models & pricing | Per GitHub docs | Copilot Pro prices and credit rates |
For AI agents — llms.txt
The homepage is JavaScript-rendered, so fetching its HTML returns a shell. ZenPick's /llms.txt is the same live catalog as plain markdown — regenerated on every request from the server-side
cache (at most ~6 hours stale), no browser and no API key required.
The file is OpenCode Go only. Zed Pro and Copilot Pro prices live in the app, where each row
shows that plan's price (and a note when the vendor has one). They are not in llms.txt yet.
One fetch answers "which OpenCode Go model should I use" without running the app. Quick answers at the top rank every leaderboard for you; the table below is grep-able and sortable in context.
Query URLs
The same ?need= and ?q= the interactive table uses — they sort or
filter the markdown before you read it.
- Leaderboard
/llms.txt?need=cheapest— cheapest-first (also: coding, design, smartest, reasoning, vision, open-source, long-context) - Search
/llms.txt?q=vision— name, provider, tags, capabilities - Both
/llms.txt?need=cheapest&q=vision - Compare (browser)
/compare?models=go:deepseek-v4.1-flash,zed:claude-sonnet-5.5— plan:id keys; mixed plans work, and bare Go ids still resolve - Raw data
/debug/export?section=models&format=json— JSON or md, per section
Quote the ID column for models, and the plan:id key for compare URLs. IDs are the stable keys; names are display text and change. Link /llms.txt and the Data as of timestamp when citing a number.
Try it
curl https://zp.svelte-apps.me/llms.txt | head -n 40
curl "https://zp.svelte-apps.me/llms.txt?need=coding&q=vision"
curl https://zp.svelte-apps.me/debug/export?section=models&format=json | jq . Thermal key
On OpenCode Go, every model gets a thermal burn band, built from OpenCode's published request counts per $12 window. It tells you how fast that model drains your quota: a cold band lasts the window, a hot one empties it in an afternoon. Zed Pro and Copilot Pro are billed against monthly token credits, so their rows show a dash for burn and quota.
computeBurnScore() in src/lib/server/burn.tsYou already pay for a plan. Make it last.
OpenCode Go, Zed Pro and GitHub Copilot Pro all cost $10 a month. ZenPick shows what each plan charges for the models they share, what a main and sub-agent pair costs per 100 requests, and how fast a Go model drains its window.
Free, no account Live Go data and hand-checked plan pages