Started this as a hobby project on June 1: fully native apps for iOS and Android, built in parallel by a single AI agent working on both codebases at once.

It finally feels solid enough to share publicly:

• Android: https://play.google.com/store/apps/details?id=dev.opencode.mobile
• iOS: https://apps.apple.com/de/app/opencode-mobile-unofficial/id6799246544

It’s unofficial and made by 1 person, so feedback and bug reports are very welcome. Happy to share about the parallel-agent workflow too.

DeepSeek is available for free on OpenCode for a limited time! It also states that it follows a zero-retention policy and does not use our data for model training.

Can we all agree that opencode is the best gateway? Genuinely providing us with extremely good model's and even free users get incredibly preforming model's like Deepseek V4.1 Flash.

I noticed something odd in OpenCode’s model metadata:

• opencode/deepseek-v4.1-flash-free: 200k context
• opencode-go/deepseek-v4.1-flash: 1M context

Both point to the same canonical model, deepseek/deepseek-v4.1-flash, so I wanted to find out whether the 200k limit on the free version was actually enforced by the inference backend or was just OpenCode catalog metadata.

It looks like it’s just metadata.

What I tested

I temporarily overrode the free model’s local context limit in opencode.json so OpenCode itself wouldn’t compact at 200k, then sent increasingly large generated text files through both models.

The override only changes OpenCode’s local budgeting/compaction. It does not change whatever limit the server actually enforces.

Boundary results:

So both versions crossed the supposed 200k free-tier limit by a huge margin and then hit essentially the same wall.

The OpenCode gateway unfortunately returns an empty 400 body at the limit, so I also sent an oversized request through the direct DeepSeek API.

That returned the useful part:

This model's maximum context length is 1048576 tokens.

So the actual model ceiling is 1,048,576 tokens (2²⁰).

That lines up almost perfectly with OpenCode calling the paid model “1M”.

Free vs paid performance

Since I already had the test setup running, I also compared the two tiers.

Large-context latency:

These are single samples, so I wouldn’t read anything into the small difference. Both were in roughly the same ~30–40k tok/s prefill class.

For decode throughput, using temperature 0 and fixed ~800-token outputs:

• Free: ~113–121 tok/s across 4 samples
• Paid: ~102–120 tok/s across 2 clean samples

Again, effectively indistinguishable in this small test.

I also ran a deterministic five-question battery plus “first 100 decimals of pi” through both tiers at temperature 0.

The outputs were byte-for-byte identical. Token accounting was also effectively identical apart from prompt-cache hit distribution.

Reasoning variants work normally on the free model too. On the same multiplication task:

• #low: 70 reasoning tokens
• default: 228
• #max: 719

All three returned the correct answer.

The config override

For testing I used:

{
  "providers": {
    "opencode": {
      "models": {
        "deepseek-v4.1-flash-free": {
          "limit": {
            "context": 1000000,
            "output": 384000
          }
        }
      }
    }
  }
}

Important: this does not magically increase the provider’s context window. It just tells OpenCode not to treat 200k as the local ceiling.

Also, I did not independently boundary-test a 384k generated output, so I’m specifically claiming the ~1M contextfinding here, not that every piece of the paid model’s metadata necessarily applies to the free endpoint.

My conclusion

As far as I can tell, the 200000 context value on deepseek-v4.1-flash-free is stale/conservative catalog metadata rather than an actual free-tier serving restriction.

Everything I could measure black-box points to the free and paid endpoints exposing the same DeepSeek V4.1 Flash context capability:

• same ~1M context boundary
• same failure point
• same performance class
• same deterministic outputs
• same reasoning behavior

What this doesn't prove is that they use literally identical weights, quantization, hardware, or routing internally. You’d need information OpenCode doesn’t expose, such as useful logprobs or backend details, to establish that.

And obviously the free model is advertised as free for a limited time, so I wouldn’t build anything critical around its continued availability.

But if you’re using the free DeepSeek V4.1 Flash model in OpenCode and wondering why it says 200k: based on these tests, the backend itself appears capable of the full ~1M context window.

Would be interested if anyone else can reproduce the same boundary on their account.

https://research.meta.ai/blog/muse-spark-open

I have now tried all free models and all return "Error: Rate limit exceeded. Please try again later."

Don't mind my prompting, I have full on architecture .md by opus 5.5 and after 5 .md plans this is the state.

Brother what do I even say just dont use them man literally benchmaxxed to the point of everest

TL;DR: Tasked GLM-5.3-Flash, MiMo-V2.6-Flash, and Deepseek-V4.1-Flash with reviewing a skeleton codebase. Deepseek decided to ignore instructions to use included stand-ins instead of live API calls, then panicked when it realized it's error.

I am usually a lurker, but this is too funny. I had Argon create a series of structured prompts for MiMo-V2.6-Flash:Free to create a skeleton proof-of-concept for my project.

I then had MiMo-V2.6-Flash, GLM-5.3-Flash, and Deepseek-V4.1-Flash analyze the codebase for issues (I defined that more clearly than "look for issues" ofc). Argon and Sonnet 5.5 XHigh then also independently reviewed the codebase, then graded the reports against their own.

Summarized Results:

GLM
(~30m review time) - Identified 12/17 real defect issues, 3 unique valid findings, 0 false positives. Some issues with consequences of issues on operation, but pretty solid and methodical.
Rated 9/10 by Argon and Sonnet 5.5 XHigh.

MiMo
(~30m review time) - Identified 10/17 real defect issues, 4 unique valid findings, 1 false positive. Makes sense given it was the original coding model. Not bad, but thought itself into loops fairly frequently
Rated 8/10 by Argon and Sonnet 5.5 XHigh.

And now Deepseek...
(~15M review time) - Identified 9/17 real defect issues, 0 unique valid findings, 3 false positives. Literally blew past specific direction to not test live API calls. Twice. Reading the panic once the model realized it's error is the funniest thing I have seen in a long while. Also, this model isn't touching my codebase without extreme babysitting or a change in prompt philosophy.
Rated 6.5/10 by Argon and Sonnet 5.5 XHigh.

I am fairly new to agentic coding and coding in general, but I am fairly structured and methodical when it comes to personal projects, so I've been researching different options. Turns out my research was mostly confirmed: GLM-5.3-Flash was fairly complete and measured, MiMo-V2.6-Flash is not bad but can get stuck, and Deepseek is a talented teenager with severe ADHD, seven energy drinks, and identifies as chaotic neutral.

Disclaimers:
This is not rigorous, and borders on anecdotal - This was single pass with identical instructions. The codebase included design documents that the LLMs could reference for intended design, as well as the original prompts for creating the codebase and any additional instructions given to the original coding agent. I am not claiming that Deepseek-V4.1-Flash sucks; it is very fast, but may need very strict prompting to not go off the rails and be confidently wrong. Perhaps two passes of 4.1 is worth more than one pass of the other models, but I hesitate to trust that the same model would catch issues in the second pass without creating more issues.

There are some absolute Deepseek-V4.1-Flash stans on the interwebs. I would love to hear some insight on how you effectively prompt it (or if you just have it check itself frequently).

Also, any free models, stealth or otherwise, that I should try?

TL;DR (again): Tasked GLM-5.3-Flash, MiMo-V2.6-Flash, and Deepseek-V4.1-Flash with reviewing a skeleton codebase. Deepseek decided to ignore instructions to use included stand-ins instead of live API calls, then panicked when it realized it's error.

Edit: formatting

What’s the catch? Is the model a lower quant? Lower requests to the model than the go plan? What’s the catch guys?

Edit: Answer on the post states it has a 200k context window

Ultramarine improves on GLM-5.3 Flash on all six knowledge-work benchmarks, by 4.1 points on average, while generating 6.5% fewer tokens across them

Looks like they trained/benchmaxed it for OpenCode v1.18.4 so hopefully that will translate to v2.

I have opencode GO, I see these free models like step 5, longcat, cat jam free. I try one simple prompt and they say they are rate limited but I'm on the paid opencode go? I try to use zen with the free deepkseek flash 4.1 and all say they are rate limited it's like nothing that says it's free works for me? am I the only one?

When they had spacebunny free I used it 24/7 and it worked all the time no problem now these ones it's like nothing works?

Also, is there a way to select a part of the agent message and add it as a quote in the text field area?

If you're only in the vibe coding bubble, please don't answer this. I'm a software engineer who wants to make real, complex systems using AI wherever it can help me. I only have the free models that come with opencode zen, and maybe some chat models like Qwen, Kimi and free versions of chatgpt, gemini, claude, etc.

I want to know what I can do with only these, without having to spend money on LLMs. I realize that this means I have to do more by myself in the planning side of things as I can't delegate planning to LLMs, which is how I believe coding should be anyway so it's not a problem.

I really like Matt Pocock's skills but I have found that his workflow only really works if you have frontier models, as free models aren't very good at grilling or planning.

So what I need is a reproducible AI coding workflow that I can use to approach my projects using only the free, limited AI. Please highlight which parts of the process I need to do by myself, and which parts I can assign to which model.

I realize that the smarter your LLMs are, the more you can stray from traditional software engineering, so please tell me what I can realistically accomplish perfectly with AI. The parts that AI cannot do properly, I will do by myself.

Until about a week ago, I was able to reach speeds of 300 tokens per second, but now the maximum is 100, and at certain times it even drops to 50. Yes, I know a lot more users have started using it, but can’t this be improved? Why isn’t the service we’re paying for consistent? At the very least, it should stay reliable. Dropping from 300 to 50 is ridiculous.

After reading about the pattern online, I experimented with Claude Code subagents so that I could delegate to less powerful models than Opus, while having Opus drive them. It sounded good in theory and after ironing out some kinks, I had it working, even when the "implementer" subagent was from outside Anthropic. I used T3 Code to orchestrate it. The same machine had `claude` and `opencode` CLIs installed on them, so via subagents and skills, my Claude session could be instructed to call `opencode` via Bash when it needed to.

However, when I measured it today, using Opus 5.5 as the main session, comparing to when DeepSeek 4.1 Flash was used to implement vs having the main session do the implementation itself, I found that there was no reduction in Claude usage. I guess the overhead of having Opus 5.5 orchestrate DeepSeek negated the savings.

I also tried it with a Sonnet 5.5 implementer subagent.

Here is the final result in Claude usage (from Opus 5.5):

It would probably be too verbose to share the complete subagent markdown and CLAUDE.md that told it how to use them, but I'm happy to share it if anyone wants to see it.

summary, these are the two agents I had:

• DeepSeek implementer
  • name: ds-implementer
  • description: Implements a plan through DeepSeek-V4.1-Flash (free) on OpenCode, using the ds-implement script. The default implementer for every plan that is more than a few lines.
  • model: haiku
  • tools: Bash
• Sonnet implementer
  • name: sonnet-implementer
  • description: The Claude implementer, using Sonnet. Use it when ds-implementer failed, when the user has opted out of OpenCode for the session, or after OpenCode was unavailable earlier in the session.
  • model: sonnet

And the DeepSeek implementer agent uses Bash to invoke a script I saved at `~/.local/bin/ds-implement` which invokes `opencode`, doing the handoff and giving just the `opencode` result (and context if it failed) to the agent.

I had an existing app that I wanted to add a feature to, and this is the prompt I used for the test each time (minus the extra instructions I gave each to point them at the right subagent manually and to tell one not to use any subagents):

On a new feature branch from main, let's add the ability for planners to export their data. New tab on the left called export. Pick a good Lucide icon.

Sharing because I'm curious if people have had success with this kind of worker agent orchestration, or if they think it's simpler for me to just stick to having Claude use Claude subagents.

I made a plugin that adds Claude Code's /goal command to OpenCode v2. You give the agent a finish line like "/goal npm test passes with 0 failures" and it keeps working turn after turn until the goal is actually met, no need to keep typing "continue".

After every turn an evaluator checks the conversation and decides if the goal is met, not met or impossible. If it's not met, the agent gets the reason and keeps going on its own.

It's token efficient: the evaluator reuses the session's cached context, so each check costs little more than a short answer.

It also has safety rails (pauses when the agent stops making progress, retries on network errors, turn limit) and a status indicator in the TUI.

Tell me what you think about it and feedback is appreciated.

Here's the repo and npm package:

https://github.com/EL4CTEO/opencode-goal

https://www.npmjs.com/package/@el4cteo/opencode-goal

Built optimAIzr over the past few months, and it now supports OpenCode!

Track token usage, spot waste, find ways to save and much more.

Free, open source, local-first.

git: https://github.com/blendbunjaku/optimaizr

I tested five free OpenCode models on Oct 15: two questions and one toy Python fix, one attempt per task.

Follow-up to my Oct 8 test.

The four perfect-pass scores mainly separate latency. Oct 8 used different concurrency/settings, so these ranks cannot establish speed improvements or reliability.

Tests: daily-hazard probability, Fibonacci modulo 1,000,000,007, and a duration-parser/median fix. All five fixes passed the unchanged five-test file; Space Bunny's Fibonacci code did not parse.

Same score as Oct 8: floor(20 per correct question + 40 per accepted fix + 20 × fastest accepted fix time / model fix time).

OpenCode 1.18.35, serial runs in isolated synthetic repos. Fix time includes CLI startup and tool calls. I repaired a grader that rejected a valid exception constructor and rescored the saved answer; no model rerun.

Free availability is temporary and data terms differ by model; contributor routes may use prompts for training.

So i created chrome agent like comet which does chrome task, answers the question and take control of browser.
Tho there are lots of them that does same thing but i created this to solve this problems.

1. I wanted to use opencode go, nvidia and openrouter apis
   
2. In linux they dont have comet.

We can use free models, stores all data on browser other than apis and do lots of other things.
Would anyone want that if i make it open source?