OpenCode Free Models
Concept of the skill
What it is: A cost-routing discipline for free and cheap agent models — deciding which open/open-weight model (and which free-tier lane) a given piece of work should run on, where each model's quality ceiling sits, and when the same work must escalate to a frontier model instead.
Mental model: Every task has a quality bar; every model has a quality ceiling and a cost. Cost-routing matches the cheapest model whose ceiling clears the task's bar, then escalates only on a concrete signal (looping, contradiction, low confidence, or the work crossing into reasoning/judgment). Free is the default lane only for work whose bar a competent open-weight model already clears.
Why it exists: Premium model capacity is finite and expensive; a large share of agent work (mechanical edits, bulk classification, high-volume triage) does not need a frontier model. Routing that work to a free/cheap model preserves premium capacity for work that genuinely needs it — but only if the ceiling/bar match is made honestly, not by reflex.
What it is NOT: It is not "always use the cheapest model" — that ignores the quality ceiling and silently corrupts work whose output is the quality bar. It is not the runtime (how to invoke a model) and not the loop (how to retry/claim). It is the per-task model choice.
Adjacent concepts: the runtime that reaches the model; the quality bar a task imposes; a model's quality ceiling and throughput; the escalation signal that promotes work to a frontier model.
One-line analogy: It is choosing the right gear for the grade — flat ground takes the cheap, fast gear; a steep climb needs the powerful one, and forcing the climb in the cheap gear strips the chain.
Common misconception: That a free model is interchangeable with a frontier model if you just retry enough — or, inversely, that free models are toys. Both are wrong: free open-weight models clear a real, sizeable band of work, but their ceiling is real, and pushing quality-creating or quality-judging work onto them produces confident garbage that poisons everything downstream.
Coverage
- The cost-routing decision: matching the cheapest model whose quality ceiling clears the task's bar
- What each free/cheap model family is good at (MiniMax M3, NVIDIA Nemotron, GLM-class, GPT-5 Nano-class) and its quality ceiling
- Which work belongs on the free lane: deterministic/mechanical edits, bulk classification/triage, high-volume extraction
- The escalate-on-signal rule — the concrete signals that promote work to a frontier model, and the warning against escalating by default
- The hard boundary: quality-creating and quality-judging work (grading, eval scoring, audit verdicts, architecture, security, correctness-critical synthesis) never goes to a free/cheap model
- The promotional, changing nature of free-tier rosters and how to confirm them at run time
Philosophy of the skill
Cost-routing is adversarial against two opposite reflexes. The first — "always use the cheapest model" — ignores the quality ceiling and silently corrupts any work whose output is the quality bar. The second — "free models are toys, use a frontier model to be safe" — wastes premium capacity on work a competent open-weight model already clears. The discipline is to refuse both reflexes and instead make the ceiling-vs-bar match explicitly, per task, escalating only on a concrete signal. The single non-negotiable line in that discipline is that retrying cannot raise a model above its ceiling, so quality-creating and quality-judging work — where a wrong answer poisons everything built on it — is always frontier work, never a cost tradeoff.
The routing decision
Match work to the cheapest model whose ceiling clears its bar. Escalate on signal, never by default.
| Work type |
Route to |
Why |
| Deterministic / mechanical (rename, format, transcribe, poll, convert) |
A script first; else the cheapest free model (GPT-5 Nano-class) |
No reasoning; a frontier model is wasted spend |
| Bulk classification / triage / extraction at volume |
A high-throughput free model (Nemotron-class) |
Throughput + a capped thinking budget; per-item bar is low |
| Large-context agentic coding on a big repo |
MiniMax M3 Free (1M context) |
Only free option with frontier-band coding AND a huge context window |
| Long iterative autonomous coding loop |
GLM-class |
Re-reviews its own strategy across many iterations instead of getting stuck |
| Quality creation or judging — grading, eval scoring, audit verdicts, architecture, security, correctness-critical synthesis |
A frontier model — NEVER a free/cheap model |
A weak judge or author silently poisons every downstream decision built on it |
Escalate to a frontier model when: the free model loops without progress, contradicts itself, returns a malformed or low-confidence result, the task crosses into reasoning/architecture/security, or the output itself becomes the quality bar (it gets graded, shipped as correct, or relied on as a decision). Do not escalate merely because a frontier model is available — that erases the cost lane.
Free-model capability table (2026 snapshot — verify the live roster)
| Model family |
Best at |
Quality ceiling / tradeoff |
| MiniMax M3 (Free) |
Frontier-band coding + agentic work; 1M-token context |
Highest-capability free lane; the strongest free default for large-context coding |
| NVIDIA Nemotron 3 (Super/Ultra) |
High-throughput reasoning, long-running agents, capped thinking budget |
Great for volume/throughput lanes; not the top-end coding choice |
| GLM-5 / GLM-5.1 |
Extended autonomous coding; strategy re-review over long loops |
Strong agentic coding; weaker on pure reasoning/knowledge tasks |
| GPT-5 Nano / nano-flash-mini class |
Cheapest, fastest; boilerplate, formatting, extraction, simple classification |
Low ceiling for multi-step reasoning / correctness-critical synthesis |
The OpenCode Zen free roster is promotional and changes — treat any list as a snapshot and confirm at run time (opencode models opencode). Trial/free models warn against sending personal or confidential data.
Strengths and weaknesses of the free lane
Strengths: real cost savings on mechanical and high-volume work; open-weight models now clear a sizeable band of agentic/coding work; throughput options for background lanes; a free tier exists at all.
Weaknesses: the roster is promotional and unstable; trial models collect feedback and warn against confidential data; the quality ceiling is real and easy to overshoot; the cost saving is illusory if the output must be redone or, worse, silently corrupts a downstream decision. Free models are a mechanical-and-volume lane, not a frontier substitute.
Verification
Use this checklist to confirm a free-model routing decision was made correctly.
Do NOT Use When
Instead of opencode-free-models |
Use |
Why |
| Choosing or operating the OpenCode runtime (invocation, provider/model strings, Zen service) |
opencode |
That is the runtime layer; this skill is the per-task model choice |
| Authoring the agent loop / retry / escalation plumbing |
autonomous-loop-patterns |
This skill decides the model; the loop skill decides the control flow |
| Budgeting GitHub Copilot premium requests / AI credits |
github-copilot |
Copilot is a paid, IDE-native lane with its own economics |
| The work is quality-creating or quality-judging |
A frontier model directly |
A free/cheap model must never be the author or judge of the quality bar |
References
references/model-facts.md — current (2026-06-08) free-model capabilities, benchmarks, and the routing table with sources.
Skill Graph context
Classification
- Subject:
agent-ops (also: ai-engineering)
- Public:
true
- Domain:
agent/models
- Scope: Cost-routing across free and cheap agent models reachable via a multi-provider runtime: what each free-tier family (MiniMax M3, NVIDIA Nemotron, GLM, GPT-5 Nano-class) is good at, its quality ceiling, which deterministic/mechanical/high-volume work to route to it, the escalate-on-signal rule, and the hard boundary that quality-creating/judging work goes to a frontier model. Portable model-capability knowledge — not any project's private model-roster config. Out: choosing/operating the OpenCode runtime (opencode), authoring the loop (autonomous-loop-patterns), Copilot credit budgeting (github-copilot).
When to use
- which free model should I send this bulk classification job to?
- is MiniMax M3 or Nemotron the better free choice for this?
- can I use a free model to grade these eval responses?
Not for
- how do I invoke opencode from a script?
- how do I write the retry loop for my agent?
- how many Copilot premium requests will this cost?
- Owned by
opencode
- Owned by
github-copilot
Related skills
- Verify with:
opencode
- Related:
opencode, github-copilot, autonomous-loop-patterns, ai-native-development
Concept
- Mental model: Every task has a quality BAR; every model has a quality CEILING and a cost. Cost-routing matches the cheapest model whose ceiling clears the task's bar, then escalates only on a concrete signal. Free is the default lane only for work whose bar a competent open-weight model already clears.
- Purpose: It exists because premium model capacity is finite and expensive while a large share of agent work — mechanical edits, bulk classification, high-volume triage — does not need a frontier model. Routing that work to a free/cheap model preserves premium capacity for work that genuinely needs it, but only if the ceiling-vs-bar match is made honestly rather than by reflex.
- Boundary: This owns the per-task MODEL CHOICE among free and cheap models, including the escalation rule and the hard quality boundary. It does NOT own the runtime (how to invoke a model), the agent loop (how to retry/claim), or a paid premium-credit lane's economics.
- Analogy: It is choosing the right gear for the grade — flat ground takes the cheap, fast gear; a steep climb needs the powerful one, and forcing the climb in the cheap gear strips the chain.
- Common misconception: That a free model is interchangeable with a frontier model if you just retry enough — or, inversely, that free models are toys. Both are wrong: open-weight models clear a real, sizeable band of work, but their ceiling is real, and retrying cannot raise a model above it, so quality-creating or quality-judging work pushed onto them produces confident garbage that poisons everything downstream.
Grounding
- Mode:
hybrid
- Truth sources:
skills/agent-ops/opencode-free-models/references/model-facts.md
Keywords
which free model to use, free agent models, opencode zen free tier, minimax nemotron glm routing, cheap model for mechanical work, model cost routing, when to escalate to frontier model, free model quality ceiling, route deterministic work to cheap model
1---2name: opencode-free-models3description: Use when deciding WHICH free or cheap agent model to route a piece of work to (e.g. MiniMax M3 Free, NVIDIA Nemotron, GLM, GPT-5 Nano, or another OpenCode Zen free-tier model), what each is good at, where its quality ceiling sits, and when to escalate the same work to a frontier model instead. Covers cost-routing: matching deterministic/mechanical/high-volume work to the cheapest model that clears its bar, and the hard rule that quality-creating and quality-judging work never goes to a free/cheap model. Do NOT use for choosing or operating the OpenCode runtime itself (use `opencode`), for authoring the agent loop (use `autonomous-loop-patterns`), or for GitHub Copilot premium-request budgeting (use `github-copilot`). Do NOT use for how do I invoke opencode from a script? Do NOT use for how do I write the retry loop for my agent? Do NOT use for how many Copilot premium requests will this cost?4license: MIT5---67# OpenCode Free Models89## Concept of the skill1011**What it is:** A cost-routing discipline for free and cheap agent models — deciding which open/open-weight model (and which free-tier lane) a given piece of work should run on, where each model's quality ceiling sits, and when the same work must escalate to a frontier model instead.1213**Mental model:** Every task has a quality *bar*; every model has a quality *ceiling* and a cost. Cost-routing matches the cheapest model whose ceiling clears the task's bar, then escalates only on a concrete signal (looping, contradiction, low confidence, or the work crossing into reasoning/judgment). Free is the default lane only for work whose bar a competent open-weight model already clears.1415**Why it exists:** Premium model capacity is finite and expensive; a large share of agent work (mechanical edits, bulk classification, high-volume triage) does not need a frontier model. Routing that work to a free/cheap model preserves premium capacity for work that genuinely needs it — but only if the ceiling/bar match is made honestly, not by reflex.1617**What it is NOT:** It is not "always use the cheapest model" — that ignores the quality ceiling and silently corrupts work whose output is the quality bar. It is not the runtime (how to invoke a model) and not the loop (how to retry/claim). It is the per-task *model choice*.1819**Adjacent concepts:** the runtime that reaches the model; the quality bar a task imposes; a model's quality ceiling and throughput; the escalation signal that promotes work to a frontier model.2021**One-line analogy:** It is choosing the right gear for the grade — flat ground takes the cheap, fast gear; a steep climb needs the powerful one, and forcing the climb in the cheap gear strips the chain.2223**Common misconception:** That a free model is interchangeable with a frontier model if you just retry enough — or, inversely, that free models are toys. Both are wrong: free open-weight models clear a real, sizeable band of work, but their ceiling is real, and pushing quality-creating or quality-judging work onto them produces confident garbage that poisons everything downstream.2425## Coverage2627- The cost-routing decision: matching the cheapest model whose quality ceiling clears the task's bar28- What each free/cheap model family is good at (MiniMax M3, NVIDIA Nemotron, GLM-class, GPT-5 Nano-class) and its quality ceiling29- Which work belongs on the free lane: deterministic/mechanical edits, bulk classification/triage, high-volume extraction30- The escalate-on-signal rule — the concrete signals that promote work to a frontier model, and the warning against escalating by default31- The hard boundary: quality-creating and quality-judging work (grading, eval scoring, audit verdicts, architecture, security, correctness-critical synthesis) never goes to a free/cheap model32- The promotional, changing nature of free-tier rosters and how to confirm them at run time3334## Philosophy of the skill3536Cost-routing is adversarial against two opposite reflexes. The first — "always use the cheapest model" — ignores the quality ceiling and silently corrupts any work whose output is the quality bar. The second — "free models are toys, use a frontier model to be safe" — wastes premium capacity on work a competent open-weight model already clears. The discipline is to refuse both reflexes and instead make the ceiling-vs-bar match explicitly, per task, escalating only on a concrete signal. The single non-negotiable line in that discipline is that retrying cannot raise a model above its ceiling, so quality-creating and quality-judging work — where a wrong answer poisons everything built on it — is always frontier work, never a cost tradeoff.3738## The routing decision3940Match work to the cheapest model whose ceiling clears its bar. Escalate on signal, never by default.4142| Work type | Route to | Why |43|---|---|---|44| Deterministic / mechanical (rename, format, transcribe, poll, convert) | A script first; else the cheapest free model (GPT-5 Nano-class) | No reasoning; a frontier model is wasted spend |45| Bulk classification / triage / extraction at volume | A high-throughput free model (Nemotron-class) | Throughput + a capped thinking budget; per-item bar is low |46| Large-context agentic coding on a big repo | MiniMax M3 Free (1M context) | Only free option with frontier-band coding AND a huge context window |47| Long iterative autonomous coding loop | GLM-class | Re-reviews its own strategy across many iterations instead of getting stuck |48| **Quality creation or judging** — grading, eval scoring, audit verdicts, architecture, security, correctness-critical synthesis | **A frontier model — NEVER a free/cheap model** | A weak judge or author silently poisons every downstream decision built on it |4950**Escalate to a frontier model when:** the free model loops without progress, contradicts itself, returns a malformed or low-confidence result, the task crosses into reasoning/architecture/security, or the output itself becomes the quality bar (it gets graded, shipped as correct, or relied on as a decision). **Do not escalate** merely because a frontier model is available — that erases the cost lane.5152## Free-model capability table (2026 snapshot — verify the live roster)5354| Model family | Best at | Quality ceiling / tradeoff |55|---|---|---|56| MiniMax M3 (Free) | Frontier-band coding + agentic work; 1M-token context | Highest-capability free lane; the strongest free default for large-context coding |57| NVIDIA Nemotron 3 (Super/Ultra) | High-throughput reasoning, long-running agents, capped thinking budget | Great for volume/throughput lanes; not the top-end coding choice |58| GLM-5 / GLM-5.1 | Extended autonomous coding; strategy re-review over long loops | Strong agentic coding; weaker on pure reasoning/knowledge tasks |59| GPT-5 Nano / nano-flash-mini class | Cheapest, fastest; boilerplate, formatting, extraction, simple classification | Low ceiling for multi-step reasoning / correctness-critical synthesis |6061The OpenCode Zen free roster is **promotional and changes** — treat any list as a snapshot and confirm at run time (`opencode models opencode`). Trial/free models warn against sending personal or confidential data.6263## Strengths and weaknesses of the free lane6465**Strengths:** real cost savings on mechanical and high-volume work; open-weight models now clear a sizeable band of agentic/coding work; throughput options for background lanes; a free tier exists at all.6667**Weaknesses:** the roster is promotional and unstable; trial models collect feedback and warn against confidential data; the quality ceiling is real and easy to overshoot; the cost saving is illusory if the output must be redone or, worse, silently corrupts a downstream decision. Free models are a *mechanical-and-volume* lane, not a frontier substitute.6869## Verification7071Use this checklist to confirm a free-model routing decision was made correctly.7273- [ ] The task's quality bar was named before a model was chosen (mechanical / high-volume / reasoning / quality-judging)74- [ ] The chosen free model's ceiling was matched to that bar — not picked purely on cost75- [ ] Quality-creating or quality-judging work (grading, eval scoring, audit verdicts, architecture, security) was routed to a frontier model, never a free/cheap one76- [ ] A concrete escalation signal (looping, contradiction, malformed/low-confidence output, scope crossing into reasoning) — not mere availability — was used to escalate77- [ ] The live free-tier roster was confirmed (`opencode models opencode`) rather than assumed from a stale list78- [ ] No confidential data was sent to a trial/free model that warns against it7980## Do NOT Use When8182| Instead of `opencode-free-models` | Use | Why |83|---|---|---|84| Choosing or operating the OpenCode runtime (invocation, provider/model strings, Zen service) | `opencode` | That is the runtime layer; this skill is the per-task model choice |85| Authoring the agent loop / retry / escalation plumbing | `autonomous-loop-patterns` | This skill decides the model; the loop skill decides the control flow |86| Budgeting GitHub Copilot premium requests / AI credits | `github-copilot` | Copilot is a paid, IDE-native lane with its own economics |87| The work is quality-creating or quality-judging | A frontier model directly | A free/cheap model must never be the author or judge of the quality bar |8889## References9091- `references/model-facts.md` — current (2026-06-08) free-model capabilities, benchmarks, and the routing table with sources.9293## Skill Graph context9495<!-- skill-graph-context:start (generated — do not edit by hand) -->9697**Classification**98- Subject: `agent-ops` (also: `ai-engineering`)99- Public: `true`100- Domain: `agent/models`101- Scope: Cost-routing across free and cheap agent models reachable via a multi-provider runtime: what each free-tier family (MiniMax M3, NVIDIA Nemotron, GLM, GPT-5 Nano-class) is good at, its quality ceiling, which deterministic/mechanical/high-volume work to route to it, the escalate-on-signal rule, and the hard boundary that quality-creating/judging work goes to a frontier model. Portable model-capability knowledge — not any project's private model-roster config. Out: choosing/operating the OpenCode runtime (opencode), authoring the loop (autonomous-loop-patterns), Copilot credit budgeting (github-copilot).102103**When to use**104- which free model should I send this bulk classification job to?105- is MiniMax M3 or Nemotron the better free choice for this?106- can I use a free model to grade these eval responses?107108**Not for**109- how do I invoke opencode from a script?110- how do I write the retry loop for my agent?111- how many Copilot premium requests will this cost?112- Owned by `opencode`113- Owned by `github-copilot`114115**Related skills**116- Verify with: `opencode`117- Related: `opencode`, `github-copilot`, `autonomous-loop-patterns`, `ai-native-development`118119**Concept**120- Mental model: Every task has a quality BAR; every model has a quality CEILING and a cost. Cost-routing matches the cheapest model whose ceiling clears the task's bar, then escalates only on a concrete signal. Free is the default lane only for work whose bar a competent open-weight model already clears.121- Purpose: It exists because premium model capacity is finite and expensive while a large share of agent work — mechanical edits, bulk classification, high-volume triage — does not need a frontier model. Routing that work to a free/cheap model preserves premium capacity for work that genuinely needs it, but only if the ceiling-vs-bar match is made honestly rather than by reflex.122- Boundary: This owns the per-task MODEL CHOICE among free and cheap models, including the escalation rule and the hard quality boundary. It does NOT own the runtime (how to invoke a model), the agent loop (how to retry/claim), or a paid premium-credit lane's economics.123- Analogy: It is choosing the right gear for the grade — flat ground takes the cheap, fast gear; a steep climb needs the powerful one, and forcing the climb in the cheap gear strips the chain.124- Common misconception: That a free model is interchangeable with a frontier model if you just retry enough — or, inversely, that free models are toys. Both are wrong: open-weight models clear a real, sizeable band of work, but their ceiling is real, and retrying cannot raise a model above it, so quality-creating or quality-judging work pushed onto them produces confident garbage that poisons everything downstream.125126**Grounding**127- Mode: `hybrid`128- Truth sources: `skills/agent-ops/opencode-free-models/references/model-facts.md`129130**Keywords**131- `which free model to use`, `free agent models`, `opencode zen free tier`, `minimax nemotron glm routing`, `cheap model for mechanical work`, `model cost routing`, `when to escalate to frontier model`, `free model quality ceiling`, `route deterministic work to cheap model`132133<!-- skill-graph-context:end -->
jacob-balslev