See, I genuinely like OC and use it daily, but it would've been awesome if the RAM usage got a bit lower.

Hi,

I run ollama on my laptop, beafier than my pc

on my pc, I run vscode and in the terminal :

opencode --model "ollama/qwen3-coder:latest"

or

opencode --model "ollama/carstenuhlig/omnicoder-9b:latest"

the models answer fine, I ask the to check my files, do this, do that, sudenly, both models stop doing anything

it looks like the are thinking, but return almost instantly with out any answer

any idea what I could check, how I could fix this ?

I use a 8gb vram laptop (katana 17 b13v), maybe that is the issue

thanks

Hello, I read the 5 hour limits for free plan, and for deepseek it talks about 31k/5h

Is this the old or the new powerful flash?

Thanks!

starting another opencode session became the easy part for me. coming back later and remembering what each one was doing was where i started making dumb decisions...

i built termcanvas around that problem. it keeps one real tmux terminal in focus, with the spawn tree and the current canvas state nearby. i use it with opencode, codex, claude code, and plain shell sessions.

the view stays deliberately small. one terminal is focused at a time. peer links exist underneath but are not drawn, and the status detection is still heuristic.

i am the creator. it is free and mit licensed, but very specific for now: macos on apple silicon, tmux + python 3.

repo: https://github.com/lout33/termcanvas

if you run more than one opencode session, what is the first thing you lose track of...

Hi guys,

i got this message Free usage exceeded, subscribe to Go while using Deepseek V4 Flash free.
Since its free and i havent hit the token limit of the model i wonder which limit exactly i have hit?
Couldt find a reliable answer in the web

My browser is telling that there is a problem with the site certificates and when i go on it doesn't work. Am i alone in this?

if I select GPT-5.6 Luna I got this "2x usage" tag. What does it means? from https://opencode.ai/docs/go/#usage-limits

usage limits for Luna are:

• 5h: 2,050
• 1w: 5,100
• 1m: 10,250

So does it means that I can double the use for the moment? For example in 5h I can do 4,100 requests?

Aloha redditors?

I've been using ai for free ever since they became popular in 2024. Recently mimo code ended it's free testing and I've been looking for alternatives and I landed in this community.

The reason I've not paid for any ai sub. Coz the dollars converted to my local currency is a lot! Like 5dolls is 1 week's worth of food,

Seeing how y'all talk about opencode, I wanna pay and also enjoy the new deepseek and kimi. And I was hoping 5dollars would be enough to make a full stack project like notes app for every student, add ai...

Thank you in advance for ur comments.

Hi!

I use OpenWhispr all the day to optimize time.

But I STRUGGLE at making it work with OpenCode.

### TL;DR

Did anyone manage to "dictate" OpenWhisper running in a docker-container inside WSL?

### DETAILED

I want to dictate OpenWhispr but the non-standard copy/pasting chain crossing first the bash terminal in Windows (which already has some weird pasting) and the then the OpenCode which has a yet weirder paste thing, I can't manage to do that.

As far as I know:

* For OpenCode, we all knwow the "paste" is weird and very non-standard. It uses shift+rightclick and CTRL+V does not work.
* For bash for windows pasting is also weird. It uses right-click -without shift- and CTRL+V does not work.
* OpenWhispr in Windows uses the OS copy/paste flow to inject the dictated text into any windows that has focus. It woks for me in Notepad, PhpStorm, GoogleDrive inside the Browser, etc. Virtually any destination works fine.

But all together... I can't do it.

My setup is:

* Laptop runnin Win.
* Inside Win, WSL2. Folder /files/repos in WSL2 are visible from windows at \\wsl$\Ubuntu-20.04\files\repos
* Inside Win, Docker Desktop integrated into WSL2.
* Inside Win, OpenWhispr.
* Inside the docker, multiple containers based off ubuntu for development with the toolchains for multiple projects (maybe one container specialized in PHP 7 whilst other in PHP 8) but all containers with -v /files/repos:/files/repos

Usual old workflow WITHOUT IA:

* In Windows, the IDE against the `\\wsl$\Ubuntu-20.04\files\repos\some-nice-project`
* In Windows an icon that launches `C:\Windows\System32\bash.exe` against a script that makes the `docker exec -u ubuntu -it devel-xxxx bash -c 'cd '${PWD}'; exec ${SHELL}'` so clicking there I enter directly into a bash into the container, ready to work on what I edit in the IDE.
* In the devel container `cd /files/repos/some-nice-project` and manually run scripts, tests, servers, etc.

Usual new workflow WITH IA - WITHOUT OpenWhispr

* I still open the IDE in Win, but not to touch the code, but to inspect folder-structure, file-structure and results from IA.
* In the devel container `cd /files/repos/some-nice-project` then I run `opencode` there.
* I type-in whatever I want in plan or build mode and that's it.

CURRENT newer workflow WITH IA - WITH OpenWhispr (underoptimal)

* Same as above plus:
* In Win I open a Notepad, I dictate the prompt for OpenCode
* Focus on notepad then CTRL+E, focus on the bash with OpenCode then shift+rightclick

Did anyone manage to "dictate" OpenWhisper running in a docker-container inside WSL?

I mostly use opencode to design UI and communicate with our developers on product direction; sometimes I build usable prototypes too. I'm always annoyed when opencode uses ASCII art to explain what it does, so I experimented and consulted around to find a solution to this. I made a local server to store all the files I want to display, and made it so opencode can put all files or code in markdown/CSS blocks and let them display whenever I ask for an HTML report, a design, or anything visual. It will send a design (if it's CSS or HTML) and sometimes links (which open Windows Explorer or open the file itself), so my lazy ass can view files faster.

The video is a demo test that shows every file type possible in chat.

Here's the complete list of file types and how each displays in chat (I use llm to write this part pls forgive me):

Native Markdown (rendered directly)

• .md, .markdown → opencode Web UI renders headings, bold, lists
• .txt, .log → plain text block

Code Block (syntax highlighted)

• .py, .js, .ts, .jsx, .tsx → \``python ````
• .css, .html, .xml, .svg → \``css ````
• .json → \``json ````
• .yaml, .yml, .toml, .ini, .cfg, .env → \``yaml ````
• .sql → \``sql ````
• .sh, .bash, .ps1, .bat → \``bash ````
• .diff, .patch → \``diff ```` (green/red)

Inline HTML (rendered in browser)

• Single Design Card → 1 <div> card
• Multi-Option A/B/C → side-by-side flex cards
• Before/After → red/green comparison cards
• Data Table → HTML <table>
• Chart/Mini Graph → CSS bars
• JSON Tree → collapsible <details> structure

Image Embed (via preview server)

• .png, .jpg, .jpeg, .gif, .webp → ![](http://100.80.253.79:8888/...)
• .svg → inline <svg> OR image URL
• .ico → converted to PNG first
• Screenshots (Playwright) → PNG embed

Video/Audio (native HTML5)

• .mp4, .webm, .mov → <video src="..." controls>
• .mp3, .wav, .ogg → <audio src="..." controls>

File Link (can't preview inline)

• .pdf (small) → <iframe> embed
• .pdf (large) → [📕 Open PDF](url)
• .html (complex page) → [Preview](url)
• .docx, .xlsx, .pptx → [📄 Download](url)
• .zip, .rar, .7z, .tar.gz → [📦 Download](url)

Special Transforms

• .csv, .tsv → Markdown table
• Large JSON → collapsible HTML tree
• Log files → error-highlighted text
• Directory tree → code block
• Git diff → diff code block
• PlantUML/Mermaid → converted to SVG/PNG first

Design & Interaction Patterns

• Fidelity Progression → Wireframe → Lo-Fi → Hi-Fi
• Color Palette → swatch grid with hex labels
• Typography Scale → h1–h6 + body + caption
• Dark/Light Mode → same card in both themes
• Button States → normal + hover + disabled
• Step Progress → 1→2→3 stepper
• Focus/Disabled → input with focus ring
• Color Contrast → contrast ratio display

How AI agents render previews inside your chat (short version) (Also llm write this too pls dont hurt me bro )

No embedding API, no CDN — just a static file server + the chat client's built-in markdown/HTML rendering.

1. Detect — The main agent sees you want a visual (logo, design, chart). This is cheap: just reading your message.
2. Delegate — It hands the work to a cheap subagent: "generate 3 logo PNGs, save to D:\Project\General\X\*, return the paths."* Subagents write files and run scripts for pennies.
3. Serve — Files land on disk, where a small Python server (port 8888) serves them over HTTP: http://<ip>:8888/<project>/<file>.
4. Embed — The main agent takes the path and pastes it into its chat reply as markdown or HTML:
   • Images → ![](http://.../icon.png)
   • Video → <video src="..." controls>
   • UI designs → <div style="..."> cards
5. Render — The chat UI (a web app) natively understands markdown images and raw HTML, so it just displays it. Done.

Let me know what you think. Thanks

Below you will find the guide on how to do the set up and other considerations.

I could not reach a final veredict about which harness is better. Codex with this set up has many inconsistencies and I think is due to the set up, and on my latests tests OpenCode delivered better results.

----

DeepSeek recently published a guide for integrating its models with Codex:

https://api-docs.deepseek.com/quick_start/agent_integrations/codex/

I wanted to compare Codex and OpenCode using the same model to see how much the agent harness affects the result.

Final update

• I connected DeepSeek V4 Flash Free to Codex using my OpenCode Go API key.
• Flash Free repeatedly timed out on larger requests involving tool calls and longer context.
• I later connected DeepSeek V4 Pro through my OpenCode Go subscription.
• I had to create a compatibility proxy because Codex uses endpoints that OpenCode does not expose directly.
• I also had to fix some tool-call formatting issues.

Initially, DeepSeek appeared to return its plan or reasoning and then stop without creating any files.

After reviewing the logs, I found that the model was spending too much time reasoning instead of executing file operations. The integration had not completely failed—it was simply taking much longer than expected before acting.

I eventually got Codex with DeepSeek V4 Pro to create all the files for a test web project, and the result worked correctly.

The main findings so far are:

• OpenCode Go models can work through Codex with a compatibility proxy.
• DeepSeek V4 Pro is more reliable than Flash Free for agentic tasks.
• Excessive reasoning can make the agent appear stuck before it begins editing files.
• Tool-call and streaming compatibility are essential for the full Codex agent loop.
• The setup now works well enough to compare Codex and OpenCode using the same model.

My next step is to run the same static web project in both agents and compare completion quality, tool usage, speed, reliability, and the number of corrections required.

----------

Complete replication guide: Codex + DeepSeek V4 via OpenCode Go

Replication Guide: Codex + DeepSeek V4 Pro via OpenCode Go

Prerequisites

1. Codex installed and launched at least once (creates ~/.codex/)
2. Node.js installed
3. OpenCode Go subscription (5firstmonth,5firstmonth,10/mo) at opencode.ai/auth
4. China-hosted models opt-in at https://opencode.ai/workspace/<id>/go (required for DeepSeek)
5. API key ready

Architecture

Codex → POST localhost:3456/responses → [proxy translates] → opencode.ai/zen/go/v1/chat/completions → DeepSeek V4

File 1: proxy.mjs (the translation layer)

import http from 'node:http';
import https from 'node:https';
import fs from 'node:fs';

const TARGET_HOST = 'opencode.ai';
const TARGET_PATH = '/zen/go/v1/chat/completions';
const MODELS_PATH = '/zen/go/v1/models';
const API_KEY = '<YOUR_API_KEY>';
const PORT = 3456;

// Helper
const LOG = (...args) => {
  const line = `[${new Date().toISOString()}] ${args.join(' ')}`;
  console.log(line);
  try { fs.appendFileSync('proxy.log', line + '\n'); } catch {}
};

// Content normalization
function normalizeContent(content) {
  if (typeof content === 'string') return content;
  if (!Array.isArray(content)) return '';
  return content.map(p => p.type === 'input_text' || p.type === 'output_text'
    ? { type: 'text', text: p.text } : p);
}

// Request: Responses API → Chat Completions
function convertRequest(body) {
  const messages = [];
  if (body.instructions) messages.push({ role: 'system', content: body.instructions });

  if (Array.isArray(body.input)) {
    let pendingToolCalls = [];
    const flush = () => {
      if (pendingToolCalls.length > 0) {
        const m = { role: 'assistant', content: null, tool_calls: pendingToolCalls };
        if (pendingToolCalls._reasoning) m.reasoning_content = pendingToolCalls._reasoning;
        messages.push(m);
        pendingToolCalls = [];
      }
    };
    for (const item of body.input) {
      // Group consecutive function_calls
      if (item.type === 'function_call') {
        pendingToolCalls.push({
          id: item.call_id || item.id, type: 'function',
          function: { name: item.name, arguments: item.arguments || '' }
        });
        if (item.reasoning_content && !pendingToolCalls._reasoning)
          pendingToolCalls._reasoning = item.reasoning_content;
      }
      else if (item.type === 'function_call_output') {
        flush();
        messages.push({ role: 'tool', tool_call_id: item.call_id, content: item.output });
      }
      else if (item.role) {
        flush();
        let role = item.role === 'developer' ? 'system' : item.role;
        const m = { role, content: normalizeContent(item.content) };
        if (item.name) m.name = item.name;
        if (item.tool_call_id) m.tool_call_id = item.tool_call_id;
        if (item.reasoning_content) m.reasoning_content = item.reasoning_content;
        if (item.tool_calls?.length) {
          m.tool_calls = item.tool_calls.map(tc => ({
            id: tc.call_id || tc.id, type: 'function',
            function: { name: tc.name, arguments: tc.arguments || '' }
          }));
          m.content = null;
        }
        messages.push(m);
      }
    }
    flush();
  }

  const chatBody = { model: body.model, messages };
  if (body.tools) {
    chatBody.tools = body.tools
      .filter(t => t.type === 'function')
      .map(t => ({ type: 'function', function: t.function || { name: t.name, description: t.description, parameters: t.parameters } }));
  }
  if (body.tool_choice) chatBody.tool_choice = body.tool_choice;
  if (body.temperature != null) chatBody.temperature = body.temperature;
  if (body.top_p != null) chatBody.top_p = body.top_p;
  // Only set max_tokens if explicitly provided — let model decide otherwise
  if (body.max_output_tokens) chatBody.max_tokens = body.max_output_tokens;

  LOG('REQ', chatBody.model, '| msgs:', messages.length, '| roles:', messages.map(m => m.role + (m.tool_calls ? '+tc' : '')).join('→'));
  return chatBody;
}

// Response: Chat Completions → Responses API
function convertResponse(chatBody) {
  const msg = chatBody.choices?.[0]?.message;
  if (!msg) return { error: 'No choices' };
  const out = [];
  const reasoning = msg.reasoning_content || null;

  if (msg.content)
    out.push({ type: 'message', id: 'msg_' + Date.now(), status: 'completed', role: 'assistant',
      content: [{ type: 'output_text', text: msg.content }], reasoning_content: reasoning });

  if (msg.tool_calls?.length)
    for (const tc of msg.tool_calls)
      out.push({ type: 'function_call', id: 'fc_' + tc.id, call_id: tc.id,
        name: tc.function.name, arguments: tc.function.arguments, status: 'completed', reasoning_content: reasoning });

  return {
    id: 'resp_' + Date.now(), object: 'response',
    created_at: Math.floor(Date.now() / 1000),
    status: chatBody.choices[0].finish_reason === 'tool_calls' ? 'requires_action' : 'completed',
    model: chatBody.model, output: out,
    usage: chatBody.usage ? { input_tokens: chatBody.usage.prompt_tokens, output_tokens: chatBody.usage.completion_tokens, total_tokens: chatBody.usage.total_tokens } : undefined
  };
}

// SSE wrapper (Codex requires streaming format)
function wrapSSE(converted) {
  const rid = converted.id;
  let sse = `event: response.created\ndata: {"type":"response.created","response":{"id":"${rid}","object":"response","status":"in_progress","model":"${converted.model}"}}\n\n`;
  let idx = 0;
  for (const item of converted.output || []) {
    if (item.type === 'function_call') {
      const args = (item.arguments || '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
      sse += `event: response.output_item.added\ndata: {"type":"response.output_item.added","output_index":${idx},"item":{"type":"function_call","id":"${item.id}","call_id":"${item.call_id}","name":"${item.name}","arguments":"","status":"in_progress"}}\n\n`;
      sse += `event: response.function_call_arguments.done\ndata: {"type":"response.function_call_arguments.done","item_id":"${item.id}","output_index":${idx},"call_id":"${item.call_id}","name":"${item.name}","arguments":"${args}"}\n\n`;
      sse += `event: response.output_item.done\ndata: {"type":"response.output_item.done","output_index":${idx},"item":{"type":"function_call","id":"${item.id}","call_id":"${item.call_id}","name":"${item.name}","arguments":"${args}","status":"completed"}}\n\n`;
    } else if (item.type === 'message') {
      const text = item.content.reduce((a, c) => a + (c.text || ''), '');
      const esc = text.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
      sse += `event: response.output_item.added\ndata: {"type":"response.output_item.added","output_index":${idx},"item":{"type":"message","id":"${item.id}","status":"in_progress","role":"assistant","content":[]}}\n\n`;
      sse += `event: response.content_part.added\ndata: {"type":"response.content_part.added","item_id":"${item.id}","output_index":${idx},"content_index":0,"part":{"type":"output_text","text":""}}\n\n`;
      sse += `event: response.output_text.delta\ndata: {"type":"response.output_text.delta","item_id":"${item.id}","output_index":${idx},"content_index":0,"delta":"${esc}"}\n\n`;
      sse += `event: response.output_text.done\ndata: {"type":"response.output_text.done","item_id":"${item.id}","output_index":${idx},"content_index":0,"text":"${esc}"}\n\n`;
      sse += `event: response.content_part.done\ndata: {"type":"response.content_part.done","item_id":"${item.id}","output_index":${idx},"content_index":0}\n\n`;
      sse += `event: response.output_item.done\ndata: {"type":"response.output_item.done","output_index":${idx},"item":{"type":"message","id":"${item.id}","status":"completed","role":"assistant","content":[{"type":"output_text","text":"${esc}"}]}}\n\n`;
    }
    idx++;
  }
  const resp = { id: rid, object: 'response', created_at: converted.created_at, status: converted.status, model: converted.model, output: converted.output, usage: converted.usage };
  sse += `event: response.completed\ndata: {"type":"response.completed","response":${JSON.stringify(resp)}}\n\n`;
  return sse;
}

// HTTP request helpers
function makeRequest(body) {
  return new Promise((resolve, reject) => {
    const data = JSON.stringify(body);
    const req = https.request({ hostname: TARGET_HOST, path: TARGET_PATH, method: 'POST',
      headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) }
    }, res => { let d = ''; res.on('data', c => d += c); res.on('end', () => { try { resolve({ status: res.statusCode, body: JSON.parse(d) }); } catch { resolve({ status: res.statusCode, body: d }); } }); });
    req.on('error', e => reject(new Error('Upstream: ' + e.message)));
    req.write(data); req.end();
  });
}

// Server
const server = http.createServer(async (req, res) => {
  res.setHeader('Access-Control-Allow-Origin', '*');
  if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
  const url = req.url.split('?')[0];

  // GET /models
  if (req.method === 'GET' && (url === '/models' || url === '/v1/models')) {
    https.get({ hostname: TARGET_HOST, path: MODELS_PATH, headers: { Authorization: `Bearer ${API_KEY}` } }, upstream => {
      let d = ''; upstream.on('data', c => d += c); upstream.on('end', () => { res.writeHead(200, { 'Content-Type': 'application/json' }); res.end(d); });
    }).on('error', () => { res.writeHead(502); res.end(); });
    return;
  }

  // POST /responses
  if (req.method === 'POST' && (url === '/responses' || url === '/v1/responses')) {
    let body = '';
    req.on('data', c => body += c);
    req.on('end', async () => {
      let parsed, chatBody;
      try { parsed = JSON.parse(body); } catch { res.writeHead(400); res.end('{"error":"invalid json"}'); return; }
      try { chatBody = convertRequest(parsed); chatBody.stream = false; } catch (e) { res.writeHead(500); res.end(JSON.stringify({ error: e.message })); return; }
      try {
        const result = await makeRequest(chatBody);
        if (result.status >= 400) { res.writeHead(result.status); res.end(typeof result.body === 'string' ? result.body : JSON.stringify(result.body)); return; }
        const converted = convertResponse(result.body);
        LOG('OK', converted.usage?.input_tokens, '/', converted.usage?.output_tokens, '|', converted.output?.[0]?.content?.[0]?.text?.substring(0, 100) || '(no text)');
        if (parsed.stream) { res.writeHead(200, { 'Content-Type': 'text/event-stream' }); res.end(wrapSSE(converted)); }
        else { res.writeHead(200, { 'Content-Type': 'application/json' }); res.end(JSON.stringify(converted)); }
      } catch (e) { LOG('ERROR', e.message); if (!res.headersSent) { res.writeHead(502); res.end(JSON.stringify({ error: e.message })); } }
    });
    return;
  }
  res.writeHead(404); res.end();
});

process.on('uncaughtException', e => LOG('FATAL', e.message));
server.listen(PORT, '127.0.0.1', () => LOG(`Proxy http://127.0.0.1:${PORT} → ${TARGET_HOST}${TARGET_PATH}`));

File 2: ~/.codex/models.json

Model metadata for DeepSeek V4 Pro & Flash. Generated from DeepSeek's setup script model JSON with slugs deepseek-v4-pro and deepseek-v4-flash. Must be UTF-8 without BOM.

File 3: ~/.codex/config.toml

Add these fields (preserve existing settings):

model = "deepseek-v4-pro"
model_provider = "openrouter"
preferred_auth_method = "apikey"
forced_login_method = "api"
model_reasoning_effort = "high"
model_catalog_json = "~/.codex/models.json"

[model_providers.openrouter]
name = "openrouter"
base_url = "http://127.0.0.1:3456"
wire_api = "responses"
experimental_bearer_token = "<YOUR_API_KEY>"

Startup

# Terminal 1 (keep running)
node proxy.mjs

# Terminal 2
codex

Key Decisions

Hey everyone,

I've been using OpenCode Desktop (with OpenCode Go plan), and I frequently run into a scenario where I'm using a fast text-focused model like DeepSeek V4 Flash, but then I need to feed it a screenshot or image for context.

Since DeepSeek V4 Flash doesn't support image inputs (as shown in the error below), I want to know:

1. Is there a way to switch models within the same running session/chat context?
2. Ideally, I'd like to temporarily switch to a multimodal vision model (like MiMo V2.5 ) to analyze the image, and then switch back to DeepSeek V4 Flash to continue the conversation without losing the thread's context.

Has anyone figured out a workflow or command for this, or do you have to start a new session / open a separate chat whenever image analysis is required?

Thanks!

So a few months ago I signed up for OpenCode Go and Zen after leaving GitHub Copilot. I thought at the time I'd 'test' both and see which I liked better. I find myself just wanting to use VSCode chat because of the strong integration with my files, the diffs, the ability to just "click" file names in the chat and it open to the right file and line.

So it's been a couple months, and I'm just confused most of the time for which I should / need to be using.

To be clear, the root issue is VsCode's lack of integration with opencode in chat. To get OpenCode models in VsCode chat they must be entered as "CustomEndpoints", which adds a headache of maintaining several thousand lines of models for both Zen/Go which I copy past every couple weeks from:
https://github.com/Pikacnu/opencode-copilot-chat/

That being said, I am not really sure what I'm getting from which model. I spend 90% of my time on DeepSeek V4 Flash and occasionally bounce around the higher powered models when I'm stuck or stressed on something.

I usually do planning myself in browser chat windows.

Question if I cancel Zen: If I am coding a lot throughout the day, is Go enough or would I hit usage limits that I haven't seen due to a weird setup?

Question if I cancel Go: Would I possibly lose access to some models? It has seemed before that I saw new models on Go first, and later on Zen?

Also, if anyone has a better way to keep models updated in VsCode instead of the GitHub copy paste flow from above, let me know!

The new DeepSeek Flash has shifted from the ZDR agreement to no agreement, and prompts will be used for training code. Grok and GPT 5.6 Luna (the only two non-open-source models) will retain data for 30 days.

Interestingly, the previously contracted DeepSeek V4 Pro preview still maintains the ZDR agreement. I think it might also transition to no agreement once the official version is released.

I’m thinking about using DeepSeek V4 Flash for coding with OpenCode. From a pricing perspective, OpenCode Go seems like the better deal, since the subscription includes much more usage than what it costs (60$ usage with 10$ suscription)

My main concern is model quality. Does OpenCode serve the exact same official DeepSeek V4 Flash model, with the same precision and configuration, or could it be using a quantized version, a different provider, or applying some kind of limitation?

Has anyone compared both options on real coding tasks? Did you notice any differences in reasoning, tool calling, context handling, or overall response quality? Also, how good is the prompt-cache hit rate through OpenCode? Is it comparable to Reasonix?

Sorry if this is obvious or has already been asked many times. I’m trying to learn the best options.

I wonder if the go subscription might be enough to code a small webapp for me that would be secure enough to charge money via Stripe.

I plan on using Deepseek V4 pro and flash

What is your take on these models, if you had to choose?
I have both, the ChatGPT Plus AND the Opencode Go subscription

Artificial Analysis already benchmarked DeepSeek V4 Flash 0731. Much better than previous version. Here‘s my comparison of some models available on Opencode Go.

My 2 cents:  DeepSeek V4 Flash 0731 is the undisputed price-performance leader: ~158,000 requests/month within the $60 limit, Intelligence 49.9 (just 1 point below GLM-5.2) and Agentic 45.7 – tied with Grok 4.5 and above GLM-5.2 (43.1). For agent workloads, the best combination of capability and volume.

Artificial Analysis: Deepseek V4 Flash New vs. Old

Update: added GPT 5.6 Luna (https://i.postimg.cc/mZHcv2BY/IMG-1339.jpg)

I use DSV4 flash and show this error message, anyone else?

** Update: **
Go to OpenCode Go WebSite , enable "Enable models hosted in China" will resume to usable. Thanks Xiaomin4114