DeepSeek V4.1 Flash in OpenCode: configuratie, kosten en de Effort Dial die niemand noemt

DeepSeek V4.1 Flash staat sinds 10 september in OpenCode Go, en de multiplier die OpenCode eraan heeft gekoppeld, heeft een gepubliceerde einddatum: 20 september. Dat is over vier dagen. Het interessante is niet de deadline — het is dat de instelling die bepaalt of dit model prettig is om mee te coderen, ontbreekt in elke installatiegids op de eerste pagina met resultaten, en dat hij in ten minste twee harnessen stilzwijgend wordt weggelaten. Dit is een draaiboek voor het richten van een coding agent op DeepSeek V4.1 Flash: de exacte model-id's, de drie integraties die vandaag zijn geverifieerd, de door de community gemelde reasoning-effort-instelling, en de faalmodus van overmatig nadenken met de mitigaties die daadwerkelijk werken.

Waar je je agent eigenlijk op richt

DeepSeek V4.1 Flash is op 2026-09-10 uitgebracht — de releaseopmerking in DeepSeek's eigen API-documentatie is op die dag gedateerd, en het is het kleinste model in de nieuwe architectuurfamilie van de leverancier. DeepSeek meldt een mixture-of-experts-backbone met 552B parameters, gebouwd op wat het een Causal Encoder–Decoder-ontwerp noemt, die tijdens prefill ongeveer 8B parameters per token activeert en tijdens decode 16B. Het accepteert tekst en afbeeldingen als invoer en retourneert tekst, biedt een contextvenster van maximaal één miljoen tokens, en zal tot 384.000 tokens in één enkele respons genereren — de context- en uitvoerlimieten zijn beide afkomstig van OrcaRouter's eigen modelpagina voor het model, die respectievelijk 1.048.576 en 384.000 vermeldt.

De leveranciersbenchmarks, uit de grafiek op de releasepagina van DeepSeek en dus door de leverancier gerapporteerd en niet geauditeerd: 30,0 op Terminal-Bench 3.0, 74,2 op DeepSWE v1.1, 88,1 op CyberGym, 54,8 op Automation-Bench en 90,9 op GPQA Diamond. Onafhankelijke scores zijn dunner gezaaid, maar ze bestaan wel — Artificial Analysis, vandaag rechtstreeks geraadpleegd, plaatst DeepSeek V4.1 Flash op 40 in zijn Intelligence Index, als zesde van 113 in zijn vergelijkingsklasse. Eén regel op diezelfde pagina is voor een coding-agent-lezer belangrijker dan de rang: Artificial Analysis bestempelt het model als zeer uitgebreid, nadat het 250 miljoen outputtokens had verbruikt om zijn Intelligence Index-run te voltooien, tegenover een mediaan van 140 miljoen. Daar komen we nog op terug.

Twee feiten over naamgeving besparen echte debugtijd. Het canonieke API-model-id van DeepSeek is nu code>deepseek-flash/code>. De oudere strings code>deepseek-v4-flash/code> en code>deepseek-v4-flash-vision-exp/code> worden nog steeds geaccepteerd, maar de modellen erachter zijn buiten gebruik gesteld en verzoeken worden bediend door V4.1 Flash tegen de Flash-prijs. Los daarvan is DeepSeek V4 Pro niet verdwenen: in de documentatie van DeepSeek staat dat de V4 Pro API-service doorloopt na 2026-09-14 met ongewijzigde facturering. Als je verteld is dat het topmodel was uitgeschakeld, is dat niet wat de eigen documentatie van de leverancier zegt.

OpenCode: twee routes naar binnen, en de id die je daadwerkelijk moet typen

Er zijn twee manieren om DeepSeek V4.1 Flash achter OpenCode te zetten, en ze hebben verschillende economische uitgangspunten.

De abonnementsroute is OpenCode Go, een abonnement van $10 per maand dat OpenCode beschrijft als een samengestelde reeks open codemodellen die het heeft getest en gebenchmarkt. De installatie bestaat uit vier stappen en er is geen configuratiebestand dat je handmatig hoeft aan te passen: meld je aan bij OpenCode Zen, neem een abonnement op Go, kopieer de API-sleutel en voer vervolgens code>/connect/code> uit in de TUI, kies OpenCode Go en plak de sleutel. Daarna code>/models/code> laat zien wat er beschikbaar is. Modelverwijzingen in de configuratie hebben de vorm code>opencode-go/<model-id>/code>.

Welk model-id? Beide. De eigen modellenlijst van de Go-gateway, vandaag opgehaald van code>https://opencode.ai/zen/go/v1/models/code>, retourneert code>deepseek-flash/code> en code>deepseek-v4.1-flash/code> als twee afzonderlijke vermeldingen, naast de oudere code>deepseek-v4-flash/code> en code>deepseek-v4-pro/code>. Elk van de eerste twee verwijst naar het model dat je wilt; code>deepseek-flash/code> is de canonieke naam en de veiligere keuze voor alles wat je van plan bent te blijven draaien.

De directe route slaat het abonnement volledig over: voer code>/connect/code> uit, zoek naar DeepSeek en plak een DeepSeek-platformsleutel. Je wordt dan door DeepSeek gefactureerd tegen de lijstprijs in plaats van te putten uit een Go-tegoed. DeepSeek publiceert de lijstprijs als off-peak $0,15 per 1M inputtokens en $0,60 per 1M outputtokens, met gecachte reads tegen $0,003 per 1M — en precies het dubbele daarvan tijdens piekuren. Zowel de OpenCode Go-documentatie als de modelpagina van OrcaRouter, vandaag gelezen, zijn het eens over die cijfers.

Wat OpenCode Go toevoegt, is de quotumstructuur, en hier zijn de cijfers het zorgvuldig lezen waard, want ze zijn de reden dat de deadline ertoe doet. De eigen documentatie van OpenCode vermeldt DeepSeek V4.1 Flash met een maandelijkse limiet van $15, momenteel met 4× vermenigvuldigd naar $60 onder een promotie die OpenCode aanduidt als 'Eindigt 20 sep'. Geschatte aantallen aanvragen worden in twee kolommen gepubliceerd: 6.500 per 5 uur / 16.250 per week / 32.500 per maand tegen het standaardtarief, of 26.000 / 65.000 / 130.000 met de 4×-vermenigvuldiger toegepast. De opbouw van het quotum is gelijk voor alle modellen — de 5-uurslimiet is 20% van het maandelijkse cijfer, de weeklimiet is 50%, en de maandlimiet is het geheel.

Dat zijn de gepubliceerde cijfers van OpenCode, vandaag gelezen uit hun Go-documentatie. Het is aan hen om de promotie te beëindigen, en er is een datum aan verbonden.

Command Code: nog steeds live, en een bugrapport dat het weten waard is

De eigen catalogus van Command Code vermeldt het model vandaag nog steeds, onder de id code>deepseek-v4-1-flash/code>, met een contextvenster van 1M tokens en dezelfde pass-through-economie: $0,15 / $0,60 buiten de piek, $0,30 / $1,20 tijdens de piek, $0,003 voor een cache-read. De overeenkomende prijzen bij twee onafhankelijke harnesses zijn geen toeval — beide geven DeepSeek's adviesprijs door in plaats van hun eigen prijs te bepalen.

De werking is eenvoudig. Installeer met code>npm i -g command-code/code>, voer het uit vanuit je projectmap, authenticeer met code>/login/code>, en gebruik code>/connect/code> als je je eigen providersleutel wilt gebruiken. code>/model <id>/code> past direct een modelwijziging toe, terwijl een kaal code>/model/code> een keuzemenu opent, en code>/effort/code> stelt de redeneerinspanning voor het huidige model in — de optie die hier het belangrijkst is.

Eén communitybugrapport is het onthouden waard voordat je de verkeerde laag debugt. Een open issue tegen een routeringslaag van derden beschrijft een reasoning-replay-cache die nooit wordt geactiveerd voor de code>command-code/deepseek-v4.1-flash/code>-id, omdat het patroon waarop de routeringslaag matcht een code>v4./code> of code>v4-/code>-segment verwacht en de string is code>v4.1/code>. Het gerapporteerde symptoom bestaat uit upstream 400-fouten die klagen dat reasoning-content die in thinking mode is geproduceerd, terug naar de API moet worden gestuurd. Dat is een communitybugrapport over een client-side matcher, geen leveranciersrichtlijn en geen probleem met het model — maar het is precies het soort ding dat om 2 uur 's nachts op een modelfout lijkt.

Claude Code, Codex en de clients die OpenCode zelf heeft gevalideerd

OpenCode Go is niet alleen voor OpenCode, en hun documentatie zegt dat ook expliciet: het is ontworpen voor OpenCode en andere coding agents die vergelijkbare requestpatronen produceren, met een gepubliceerde lijst van clients waarvan is gevalideerd dat ze werken. Op die lijst staan momenteel Hermes, Claude Code, Codex, ZCode en Pi — en voor Claude Code luidt de opmerking dat het "de eigen native session header herkent. Er is geen custom-header-wrapper nodig." Daar horen twee vereisten bij: identificeer je client met zijn eigen user agent in plaats van een generieke SDK-naam, en stuur bij elk gesprek een stabiele session identifier mee in de code>x-opencode-session/code>-header, wat hun routing en prompt caching laat werken. Voor Hermes doet de gevalideerde build ertoe — de header-fix is na v0.21.0 samengevoegd, dus die release alleen bevat hem niet.

Er is ook een route zonder enig abonnement, die DeepSeeks Anthropic-compatibele endpoint rechtstreeks gebruikt. Stel code>ANTHROPIC_BASE_URL/code> in op code>https://api.deepseek.com/anthropic/code>, code>ANTHROPIC_AUTH_TOKEN/code> op je DeepSeek-sleutel, en richt de modelvariabelen op het model. Claude-modelnamen worden onderweg omgezet: alles wat begint met code>claude-opus/code> gaat naar DeepSeek V4 Pro en wordt gefactureerd tegen de V4 Pro-prijs, terwijl code>claude-sonnet/code> en code>claude-haiku/code> naar het Flash-model gaan. Het achtervoegsel code>[1m]/code> op de modelstring vraagt de variant met een context van een miljoen tokens aan. DeepSeeks eigen gids voor deze installatie stelt ook code>CLAUDE_CODE_EFFORT_LEVEL=max/code> in en zet het venster voor automatische compactie vast op 786432 tokens.

Die laatste variabele is waar een communityfix zit. Er bestaat een workaround-proxy, want recente Claude Code-builds sturen code>thinking: {"type": "disabled"}/code> bij subagentverzoeken, terwijl code>CLAUDE_CODE_EFFORT_LEVEL=max/code> een reasoning-effort-parameter toevoegt, en DeepSeek's endpoint in Anthropic-formaat verwerpt die combinatie met een melding dat denkopties niet uitgeschakeld kunnen worden wanneer reasoning effort is ingesteld. De gerapporteerde workaround is beperkt — verwijder de effort-parameter alleen uit subagentverzoeken, en laat de hoofdagent ongemoeid. Beschouw het als een bevinding uit de community over een mismatch in het client/server-contract, en verwacht dat de exacte versiegrens verschuift.

De inspanningsregelaar: 1–100, en waarom "laag" 50 betekent

Alles in deze sectie is een communitybevinding, niet een richtlijn van de leverancier. DeepSeek publiceert geen toewijzing van presets aan nummers die wij kunnen verifiëren, en de onderstaande nummers komen uit verslagen van praktijkmensen en documentatie van harnesses van derden. Ze zijn consistent genoeg tussen bronnen om nuttig te zijn, en onbevestigd genoeg dat je ze op je eigen werk zou moeten testen.

DeepSeek V4.1 Flash is getraind met een continue scalar voor redeneerinspanning van 1 tot 100. Het is geen tokenlimiet — het bepaalt waar het model zich op een curve bevindt die het trainingsproces heeft geleerd, waarbij lagere inspanning meer druk uitoefent om beknopt te zijn en hogere inspanning extra redeneren goedkoper maakt. Drie openbare presets vallen op die schaal:

Laag — 50, het kortste traject, en de preset die de besturing zijn reputatie van goedkoopheid bezorgt.

• Hoog — 75, en het niveau dat de meeste bronnen uit de community beschrijven als het verstandige plafond voor agentwerk.

• Max — 100, waarbij de straf op de redeneerlengte volledig wordt verwijderd.

Wat de knop oplevert is reëel, maar het rendement neemt sterk af. Eén benchmarkronde uit de community meldde dat het verhogen van de effort van 25 naar 100 Terminal-Bench 2.1 van 82,4 naar 90,6 bracht, terwijl het totale aantal outputtokens ruwweg met een factor 2,5 toenam. Rapporten komen overeen dat een effort ergens tussen 60 en 80 het grootste deel van de beschikbare nauwkeurigheid binnenhaalt voor minder dan de helft van het tokenbudget, waarbij max nog eens 1,6–1,8× aan agenttrajecten toevoegt voor een marginale winst.

De standaardwaarde is het punt waarover niemand het eens is. Sommige harness-documentatie en verslagen van gebruikers zeggen dat een niet-ingestelde effort uitkomt op high; anderen beschrijven de serverstandaard simpelweg als onbekend. Wat wél gedocumenteerd is in plaats van betwist, is dat twee harness-integraties de parameter helemaal niet bleken te verzenden — het providerprofiel OpenCode Go en een native DeepSeek-profiel lieten beide na om code>reasoning_effort/code> te verzenden voor de code>deepseek-flash/code>-slug, omdat hun match-guard een code>deepseek-v…/code>-prefix verwachtte die de canonieke id niet heeft. In beide gevallen werd de door de gebruiker gekozen instelling stilzwijgend vervangen door de providerstandaard. Als je client een effort-regelaar toont, is dat geen bewijs dat die op de lijn staat. Log één request-body en kijk.

Nog een eigenaardigheid uit dezelfde rapporten: het OpenCode Go-endpoint accepteert code>low/code>, code>medium/code>, code>high/code> en code>max/code>, maar weigert een geheel getal voor effort — er is gemeld dat een waarde van 80 HTTP 400 retourneert. De 1–100-instelling bestaat in het model, maar wordt niet overal als een onbewerkt getal beschikbaar gesteld, dus "stel effort in op 65" is mogelijk niet uit te drukken in je client.

De faalmodus van overmatig nadenken, en wat die echt verhelpt

Dit is de faalmodus die bepaalt of je het model in je proces houdt. Communityrapporten beschrijven dat DeepSeek V4.1 Flash blijft redeneren nadat het werk klaar is: opnieuw argumenteren over een punt dat het al correct heeft beantwoord, vertellen hoe het zijn eigen verkeerde aannames corrigeert, en lange redeneerketens produceren met een lage informatiedichtheid. Een professional meldde dat de redeneeroutput meer dan een uur bleef doorgaan in een CLI-sessie voor programmeren. Een ander meldde dat het helemaal niet lukte om het model een lange benchmarkrun te laten afronden.

Een bronnotitie bij dat tweede rapport, want het is het soort bewering dat wordt witgewassen. Het komt uit een communitythread over het betrouwbaar draaien van het model, en Reddit blokkeert onze fetcher, dus konden we de thread niet rechtstreeks lezen — we geven het rapport door in plaats van een pagina te citeren die we hebben geopend. Wat we onafhankelijk konden verifiëren, is de vorm van het probleem, en daar is het externe bewijs ongewoon helder: Artificial Analysis markeert op zijn eigen pagina het model als zeer verbose: het verbruikt 250M outputtokens om een run te voltooien die het mediane vergelijkingsmodel ervan in 140M afrondt. Dat is ongeveer 1,8×, gemeten door een derde partij, op een vaste taakset. De forumrapporten en de onafhankelijke metriek beschrijven hetzelfde gedrag.

De mitigerende maatregelen die uit die rapporten voortkomen, allemaal afkomstig van de community:

• Zet inspanning vast op hoog of lager en weiger het te laten opkrikken. De meest expliciete oplossing die in het wild wordt gezien, is een routeringsplug-in die speciaal is geschreven om inspanningsescalatie te stoppen: beurtdiepte draagt niets bij aan de escalatiescore, alleen een mislukt toolresultaat of een identieke herhaling telt mee, escalatie is gemaximeerd, en max is opt-in en standaard gedegradeerd. Als jouw harness een agent zijn eigen inspanning laat verhogen naarmate een run langer duurt, is dat het mechanisme dat je moet uitschakelen.

• Voer max niet standaard uit. Meerdere gebruikers melden dat max blijft doorgaan in plaats van tot een resultaat te komen bij routinewerk, en dat terugschakelen naar high dat oplost.

• Beperk code>max_tokens/code> op interactieve paden. Een uitvoerplafond van 384.000 tokens is een limiet, geen doel, en een lus die niet termineert is duur bij dat plafond.

• Verifieer dat de parameter wordt verzonden. Aangezien er twee testharnassen zijn gevonden die hem stilzwijgend lieten vallen, zijn "ik heb hem op high gezet" en "high heeft de API bereikt" verschillende beweringen.

• De harness is belangrijker dan je zou verwachten. Praktijkmensen die dezelfde gewichten draaien, melden sterk uiteenlopend gedrag tussen shells — hetzelfde model dat in de ene harness met zichzelf twist en het signaal begraaft, roept in een andere geen van die klachten op. Dat is een observatie uit de gemeenschap over het gedrag van de harness, niet een claim van een leverancier over het model, maar het is het meest herhaalde advies in de rapporten.

Wat een codeerloop daadwerkelijk kost bij deze tarieven

DeepSeeks catalogusprijs is $0,15 per 1M invoertokens en $0,60 per 1M uitvoertokens buiten de piekuren — de uitvoer is vier keer zo duur als de invoer, en dat is het eerste dat je moet internaliseren bij een agent die zowel redeneringen als code genereert.

Neem een realistische agentbeurt: 60.000 tokens context (systeemprompt, toolschema's, een repo-fragment, gespreksgeschiedenis) erin, en 3.000 tokens aan redenering plus een patch eruit. Dat is 60.000 × $0,15/1 mln = $0,009 erin, plus 3.000 × $0,60/1 mln = $0,0018 eruit, dus ongeveer 1,1 cent per beurt. Tweehonderd zulke beurten op een werkdag is ongeveer $2,16, of ongeveer $47 over een maand aan weekdagen tegen het off-peaktarief. Dat is de rekensom die een maandelijkse vergoeding van $15 met daarbovenop een 4×-promotie ruimhartig laat lijken — en de rekensom die breedsprakigheid tot het punt maakt om in de gaten te houden.

Want hier ligt de hefboom verscholen in dat Artificial Analysis-getal. Dat het model op een vaste takenreeks 1,8× de mediane outputtokens gebruikt, betekent dat een outputgebonden loop 1,8× zoveel kost als de tokenprijs alleen suggereert. En de effort-dial is precies daarvoor de regelaar. Meldingen uit de community schatten de overgang van max naar high op ongeveer een halvering van de outputtokens — een veel grotere schommeling dan wat het piek-/dalschema je zal aandoen. De effort-instelling is de grote hefboom; het schema is de gratis hefboom.

Wat de moeite waard is om te weten voordat je iets inplant: piekuren zijn 01:00–04:00 en 06:00–10:00 UTC, van maandag tot en met vrijdag, en al het andere, inclusief weekends, valt buiten de piek. Een Europees team dat van 09:00–18:00 CET werkt, raakt nooit de piek. Een team in Beijing dat dezelfde lokale uren werkt, zit van 09:00–12:00 en 14:00–18:00 in de piek — zeven van de negen werkuren tegen dubbele prijs. Hetzelfde model, dezelfde code, de dubbele rekening, volledig bepaald door de tijdzone.

De andere kosteloze besparing is het tarief voor gecachte leesbewerkingen, $0,003 per 1 miljoen tegenover $0,15 voor nieuwe invoer — een vijftigste. De prompt van een coding agent bestaat grotendeels uit een stabiele prefix: systeeminstructies, tooldefinities, de delen van de repo die niet veranderen. Houd het stabiele materiaal vooraan, laat de variabele inhoud erachter volgen, en de cache aan providerzijde doet de rest. Of het kortingstarief voor gecachte invoer geldt, en onder welke voorwaarden, wordt bepaald door DeepSeek en niet door de client, dus controleer dit in de actuele documentatie voordat je er een budget op baseert — onze eigen modelpagina voor code>deepseek/deepseek-v4.1-flash/code> zegt hetzelfde: dat het tarief voor gecachte invoer de voorwaarden van de provider volgt.

Als je liever geen tweede abonnement toevoegt om het model te evalueren, is dezelfde id beschikbaar via één OpenAI-compatibel endpoint vóór onze hele catalogus, tegen het tarief van de provider met 0% opslag — dus een prijswijziging aan de kant van DeepSeek is hier dezelfde dag live in plaats van bij de volgende prijsherziening. Dat is het belangrijkst voor precies de situatie die dit artikel beschrijft: een model met een gedocumenteerde neiging om door te gaan, op een pad waarvoor je de evaluatie nog niet hebt afgerond. Een fallback-keten betekent dat een beurt die misgaat bij een ander model terechtkomt voordat het antwoord begint, in plaats van dat het verzoek mislukt.

552B, 748B of 763B — de vraag naar de grootte is echt nog open

Herhaal geen parameteraantal voor dit model als vaststaand, want er zijn drie verschillende getallen in omloop en geen ervan is simpelweg onjuist.

DeepSeek's eigen modelkaart beschrijft een model met "552B backbone-parameters", en dat is het door de leverancier gerapporteerde cijfer — het is ook het getal dat in het specificatiepaneel op onze eigen modelpagina staat. Dezelfde kaart vermeldt apart een "Engram conditional memory"-module van 196B parameters, "spaarzaam geraadpleegd via op tokens gebaseerde lookup". Tel je die twee op, dan krijg je 748B, de rekensom waarop de community-analyse binnen uren na de release uitkwam. En de bestandsmetadata in dezelfde modelrepository vermeldt een modelgrootte van 763B parameters, wat weer een derde cijfer is.

Het ogenschijnlijke meningsverschil is veeleer een definitiekwestie dan een tegenstrijdigheid. Opgezochte Engram-parameters kosten geheugen, maar bijna geen rekenwerk per token, terwijl berekende backbone-parameters bij elk token tijd kosten — en dat is precies waarom de leverancier ze apart rapporteert en waarom het vergelijken van de belangrijkste cijfers van twee modellen met verschillende architecturen je heel weinig zegt.

Wat niet serieus wordt betwist, is het aantal actieve parameters: ongeveer 8B per token tijdens prefill en 16B tijdens decode, en dat is het getal dat daadwerkelijk de inferentiekosten bepaalt. De gewichten zijn open onder een MIT-licentie als je dit zelf wilt controleren. Beschouw 552B als door de leverancier gerapporteerd, 748B als een geloofwaardig totaal van de community, en elke bewering dat de kwestie van de omvang is afgesloten als voorbarig.

Wat te doen vóór de 20e

Als je DeepSeek V4.1 Flash in een coding agent gaat proberen, is de volgorde die het minst tijd verspilt: kies eerst de harness, zet daarna de effort vast en meet vervolgens.

Op de harness is de eerlijke samenvatting van de verificatie van vandaag dat alle drie de routes werken en dat ze verschillen in wat ze van je vragen. OpenCode Go is een abonnement van $10/maand met een promotionele multiplier die op 20 september verloopt, en de installatie is code>/connect/code> plus code>/models/code> zonder een bestand om te bewerken. Command Code vermeldt het model live in zijn eigen catalogus, wisselt met code>/model <id>/code>, en biedt effort aan als een eersteklas commando. Claude Code bereikt het ofwel via het pad voor gevalideerde clients van OpenCode Go — waar het geen aangepaste header-wrapper nodig heeft — of rechtstreeks tegen DeepSeek's Anthropic-formaat endpoint, waar het conflict rond subagent-effort de bekende ruwe rand is.

Stel 'effort' expliciet in en zet het vrij laag: high, of de modeldefault als high dat blijkt te zijn, en niet max. Bevestig daarna dat het je machine heeft verlaten, want van twee harnesses is gebleken dat ze het laten vallen.

Wat meten betreft: let op outputtokens in plaats van wandkloktijd. De breedsprakigheid is de kostenpost, de inspanningsregelaar is de bediening, en het piekschema is een tijdzone-toevalligheid die je gratis kunt vermijden.

En wat betreft de grootteclaims die deze week aan u worden voorgehouden — 552B, 748B, 763B — het nuttige antwoord is dat de leverancier zijn backbone rapporteert, de community de geheugenmodule toevoegt, en de metadata van de repository weer iets anders zegt. Wie een van die getallen als het definitieve antwoord presenteert, heeft een getal gekozen in plaats van er een te controleren.