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

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.

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.

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

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.

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.

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

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

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?

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

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?

pls help me

I want to know what models people use, like models that output good code, and doesn't hallucinate, because running a test like making a webpage, doesn't test how it does when it's really coding. Thank you!

Any ideas? I can’t do anything right now. The application is frozen and no session is open.

Just asking, they claim it has 3x the usage of Claude Pro, but I’m super hesitant. I once bought a $5 token plan from Mimo and only got $5 worth of usage (actually around $4.60 by my calculations). I really don't want to get scammed, so if any of you have already gotten burned, I’d appreciate it if you could let us know.

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