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.

GitHub 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.

fig.02 — system schematic data flow
input
modelgrep + LLM Stats
benchmarks · pricing
OpenCode Go + models.dev
catalog · lifecycle
Zed + Copilot docs
plan models · prices
engine
FETCH
HTTP · auth
CACHE
6h TTL · SWR
INFER
tag · score · rank
PLAN
merge · price · stack
output
Model Table
all plans · filterable
Agent Stack
main · sub · cost
Compare
plan:id · mixed plans
Quota Calculator
Go · token → request
scale 3 plans · one table
latency cache hit < 50ms
refresh 6h live · plans hand-checked

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

$10 /mo
per plan

OpenCode Go, Zed Pro and GitHub Copilot Pro each cost the same.

—
models tracked

Loading…

—
plan listings

Loading…

6 h
cache TTL

Stale-while-revalidate; 15 minutes when an upstream build is partial.

Free
to use

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.

Live, OpenCode Go only. Interact with it — filter by task

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.

data_sources.json 9 sources · 3 require attribution
ProviderLicenseUse 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 termsBenchmark scores, rankings, pricing, model metadata
Gamefeel Benchmark
attribution required
Published data, credited with a linkGamefeel v1.4 game-development scores and price per task
opencode.ai/v2/docs/console/go Per OpenCode Go docsModel 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 docsZed Pro model list and list prices
zed.dev · plans & pricing Per Zed docsZed Pro monthly price, included token credit and 10% markup
GitHub · supported models Per GitHub docsCopilot Pro model list
GitHub · models & pricing Per GitHub docsCopilot 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.

free
Unlimited
Free preview models. No quota cost at all.
excellent
> 11,000
Workhorse models. Use these for volume.
good
3,500 – 11,000
Economical for steady use.
moderate
1,000 – 3,500
Balanced daily drivers.
high
500 – 1,000
Premium models for focused, short sessions.
extreme
< 500
Burns fastest. A handful of requests empties the $12 window.
Source function: computeBurnScore() in src/lib/server/burn.ts

You 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