OpenCode is one of the best open-source AI coding agents available right now. It's terminal-first, model-agnostic, and built for developers who want actual agentic coding workflows, not just autocomplete with extra steps.
The problem is familiar: great tool, unpredictable costs. The moment you start running OpenCode on heavy tasks, multi-file refactors, codebase-wide reviews, test generation, token usage climbs fast. Most developers end up rationing their model usage without realizing it. Smaller model. Fewer passes. Less context. The tool doesn't get worse; how you use it does.
Featherless fixes this. Flat monthly rate, 30,000+ open-source models, no per-token billing. Here's how to connect the two and what to actually use them for.
What is OpenCode?
OpenCode is an open-source AI coding agent that runs in your terminal. It supports 75+ LLM providers, has a full TUI interface, runs non-interactively for scripts and CI/CD pipelines, and supports custom agent configurations for specialized tasks like code review, debugging, or documentation. Think of it as a coding agent you can actually configure, not one locked to a single model or provider.
Because OpenCode is provider-agnostic, it works with any OpenAI-compatible API endpoint. Which means Featherless drops in cleanly.
Connecting OpenCode to Featherless
Add a custom provider to your opencode.json config, either global (~/.config/opencode/opencode.json) or project-level (opencode.json in your project root):
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"featherless": {
"npm": "@ai-sdk/openai-compatible",
"options": {
"baseURL": "https://api.featherless.ai/v1",
"apiKey": "your-featherless-api-key"
},
"models": {
"MiniMaxAI/MiniMax-M2.5": {},
"deepseek-ai/DeepSeek-V3-0324": {},
"moonshotai/Kimi-K2.5": {},
"Qwen/Qwen3-Coder-30B-A3B": {}
}
}
},
"model": "featherless/MiniMaxAI/MiniMax-M2.5"
}
Get your API key from the Featherless dashboard. Once this config is in place, run /models inside OpenCode to select any Featherless model and swap between them without touching your workflow.
Which open-source models to use with OpenCode
Not every model in a 30,000-model catalog is built for coding agents. Here are the ones worth running for serious development work:
- MiniMax M2.5: Currently sits at 80.2% on SWE-Bench Verified, which measures real-world GitHub issue resolution. What makes it stand out for OpenCode specifically is how it approaches tasks: before writing any code, it decomposes the problem, plans the structure, and thinks through dependencies. Strong on multi-file tasks where reasoning across the codebase matters.
- Kimi K2.5: A 1-trillion parameter MoE model with 32B active parameters. One of the most-used models on Featherless right now. Excellent tool-calling reliability, which matters a lot for agentic workflows where OpenCode is issuing multiple sequential operations. Handles long context well, so you can give it a large codebase slice and trust it to stay coherent.
- DeepSeek V3.2: Frontier-level performance on multilingual codebases and complex debugging. 73.1% on SWE-Bench Verified, 83.3% on LiveCodeBench. A reliable workhorse for agentic workflows involving tool use and multi-step reasoning.
- Qwen3-Coder-30B-A3B: A coding-first MoE model built for agentic workflows. 256K native context means it can read a large codebase in a single pass. Strong tool-calling support, efficient at 3B active parameters despite 30B total. Good choice when you want repository-scale code understanding without the weight of a dense 70B model.
All of these are available on the $75/month Featherless Scale plan.
What to actually use OpenCode + Featherless for
This combination works best on tasks that need depth over speed, where you hand something off, let the model work, and come back to something worth reading.
- Codebase-wide code review. Point OpenCode at a module, a PR diff, or a service you haven't touched in months. A model like MiniMax M2.5 or Kimi K2.5 reads it properly, flags issues, and suggests concrete fixes, the kind of review a senior dev would give if they had unlimited time. With flat-rate pricing, you run it properly instead of cutting context to save tokens.
- Refactoring with full context. Codebase refactors need models that hold a lot of state and reason through consequences before touching anything. You can feed OpenCode the entire module, ask for a refactor proposal, review it, and iterate, without calculating whether the third pass is worth the cost.
- Automated test generation. Legacy code rarely has good test coverage. Writing tests for someone else's code is exactly the kind of slow, deliberate task that benefits from a model doing the thinking. Run it in non-interactive mode overnight if needed:
bash
opencode run "Generate comprehensive unit tests for the auth module. Cover edge cases and error paths." -q
- Multi-file bug investigation. You know the symptom, not the source. OpenCode traces it through files, reads stack traces, and proposes a fix. This is precisely where per-token billing punishes you most, and where flat-rate pricing pays off most.
- Documentation passes. Accurate documentation requires the model to actually understand the code, which means longer context windows and more tokens than most developers budget for. With Featherless, you stop budgeting for it and just run it.
- CI/CD integration. OpenCode runs cleanly in non-interactive mode, which means you can wire it into your GitHub Actions pipeline for automated PR review:
yaml
- name: AI Code Review
run: opencode run "Review this PR diff for bugs, security issues, and code quality. Be specific." -q
Why Featherless makes sense for OpenCode
The flat-rate model isn't just convenient, it changes how you use the tool. When every token has a price tag, you optimize for cost instead of quality. You pick a smaller model. You give it less context. You skip the second review pass.
Featherless removes that calculation entirely. The $75/month Scale plan gives you access to all the models above with no per-token meter running. Run OpenCode on the full codebase. Let Kimi K2.5 read the whole service. Do the refactor properly. The bill is the same either way.
For developers running OpenCode regularly, especially on larger codebases, this is the practical choice.
OPTIONAL FOOTNOTE: The $25/month Premium plan also unlocks all models in this list and works fine for solo developers running OpenCode on small personal projects. The Scale plan is worth it if you're running multiple concurrent OpenCode sessions, integrating into CI/CD pipelines that fire in parallel, or if private/no-log usage matters for your work.
Get started
- Sign up at featherless.ai and grab your API key from the dashboard
- Add the provider config to your opencode.json
- Run /models in OpenCode and select your model
- Run /init to let OpenCode analyze your project and generate AGENTS.md
OpenCode docs: opencode.ai/docs Featherless model catalog: featherless.ai/models