OpenCode Setup: Zen Models, Keys and Route Comparison

OpenCode pairs a terminal-native agent with Zen's managed model routes: free tiers for learning, funded keys for production, one configuration surface for both. Most users start on free models and never configure further — until deadlines arrive with quotas attached. This guide sets up OpenCode properly from the start: Zen authentication, provider keys that matter, route comparison with real tickets, and team conventions that keep terminal agent work cheap and resilient permanently.

Zen and the free tier, honestly

Authenticate OpenCode with Zen to access managed routes including free-tier models that cover learning and evaluation generously. Understand the free tier's shape: request quotas, model availability windows, fair-use limits that bind exactly when work gets serious. Free is for proving value, not for production dependence — plan the funded route while everything still works.

Fund keys for the models you actually use before deadlines depend on them. The transition is configuration, not migration: same CLI, same habits, different billing behind familiar model names. Developers who fund proactively never think about quotas; developers who wait meet them mid-sprint with no baseline for comparison. Timing beatsPermanence here — fund early, evaluate calmly.

• Zen authentication for managed routes
• Free tier scope and quota shape
• When free stops fitting
• Funded keys before deadlines

Add provider keys deliberately

Add keys for the providers behind your actual tickets — not every provider available, just the ones your work touches. Configure base URLs and exact model strings from current catalogs; identifiers churn and stale names fail confusingly. Verify each route with a trivial ticket before depending on it; identical behavior across routes confirms plumbing worth trusting.

Change one thing per round: new key with familiar models first, new models on proven keys after. Document working combinations per provider for team reuse. The access layer done methodically takes an afternoon and never needs revisiting except when catalogs change — check those first in any future mystery, before doubting the tool.

• Provider keys that matter
• Exact strings and URLs
• Trivial verification per route
• One variable per change

Compare routes with real tickets

Score Zen free, Zen funded and direct provider routes on identical real tickets for two weeks. Weight continuity — completion without quota interruption — highest, since deadlines punish gaps more than prices. Then compute spend per merged ticket with review time included. Keep every route configured permanently afterward; each is the others' outage fallback at negligible idle cost.

Expect different winners per ticket shape: free routes for learning and light work, funded routes for deadline production, direct providers for specialty needs. Document the routing that emerges so the team inherits economics instead of improvising. Revisit quarterly as generations, prices and quotas all move faster than habits do.

• Identical tickets per route
• Continuity scored highest
• Spend per merged ticket
• All routes warm permanently

Team OpenCode without chaos

Version-control shareable OpenCode configuration holding everything except secrets; overlay personal keys per developer. Put budgets and alerts on every shared key before team growth reaches them. New hires clone the config, paste one key and match team economics immediately — onboarding measured in minutes with zero tribal knowledge required.

Review per-developer spend monthly to catch misrouted work and runaway loops early. Keep routing conventions visible where the team works. The system stays boring deliberately: files, variables, quarterly reviews. Boring billing infrastructure is what lets exciting terminal agent work happen without finance getting involved or deadlines getting surprised.

• Shareable configs versioned
• Secrets overlaid personally
• Budgets on shared keys
• Onboarding as clone plus key

Operate routes permanently

Review every route quarterly: prices, quotas, models offered, reliability observed. Monitor quota posture weekly during heavy periods — free tiers bind suddenly and funded keys deserve usage awareness. Test each fallback route routinely under calm conditions; theoretical redundancy fails theoretically until proven with real requests.

Maintain the routing document as living infrastructure with reasons attached to every assignment. New generations, price moves and quota changes all arrive regularly; each becomes a small routing tweak for prepared teams and a migration project for unprepared ones. The maintenance burden is an hour per quarter guarding economics that compound every ticket indefinitely.

• Quarterly route reviews
• Quota posture monitored
• Fallbacks tested routinely
• Routing doc as infrastructure

Frequently asked questions

Do I need an API key for OpenCode?

Authenticate with Zen for managed free models, or bring provider keys for specific models. The free tier covers evaluation generously; steady professional use deserves a funded key before deadlines depend on quotas.

Free tier or paid keys first?

Start with Zen free models to learn the workflows, then add funded keys for the models you actually use. Mirror the routing you will run in production from the beginning — habits formed on free quotas transfer cleanly.

How do I compare Zen versus direct providers?

Compare identical tickets on each route for a week: completion without intervention first, then spend per merged ticket. Keep all routes configured as mutual fallbacks regardless of outcome.

What breaks OpenCode provider setups?

Exact model strings from catalogs, base URLs copied precisely, keys with quota. Verify each piece alone; compound changes create compound mysteries that waste afternoons.

How do teams standardize OpenCode setups?

Version-control shareable configuration, overlay secrets per developer, set budgets on shared keys, and review quarterly. New hires clone working configs on day one.

Related guides

• Best AI coding tools 2026: an honest shortlist
• AI Subscription vs API: A Developer Cost Model That Works

Last updated: 2026-09-28