ARTEMIS vs Gemma 4 12B: een harnas en een brein zijn niet hetzelfde soort aankoop

Googles ARTEMIS en Gemma 4 12B concurreren niet met elkaar, en de snelste manier om een week te verliezen is ze in een vergelijkingstabel te zetten en een winnaar te kiezen. ARTEMIS, dat Google in augustus 2026 onder Apache 2.0 open-source heeft gemaakt, is een Android-automatiseringsharnas: het neemt een zin, bestuurt via ADB een echte telefoon en rapporteert wat er is gebeurd. Gemma 4 12B, op 3 juni 2026 uitgebracht door Google DeepMind, is een dense multimodaal open-weights-model met 12 miljard parameters — een brein dat je op een laptop kunt draaien, geen systeem dat op een scherm kan tikken. Een van de twee kan niet zien, beslissen of handelen zonder dat er iets van de andere soort aan vastzit; de andere kan helemaal geen apparaat vasthouden. Maar de vergelijking is de moeite waard, want de vraag eronder is de vraag die elk mobiel team op dit moment stelt: kan een klein open model dat je volledig bezit Android-automatisering uitvoeren, of heb je een gehost frontier-model nodig achter een harnas zoals ARTEMIS? Die vraag heeft een echt antwoord, en het is niet het antwoord dat de lanceringspost van een van beide leveranciers suggereert.

Eerst de categoriefout, simpel gesteld

ARTEMIS bevat geen model. Op zijn eigen badge staat "Multi-Model — Gemini | Claude | GPT-4o | Qwen-VL", en het bestand dat bepaalt welke je gebruikt is code>config/artemis.jsonc/code>. Het is een control loop: een locator die toegankelijkheid vooropstelt, een veiligheidscontrole die pop-ups opruimt voordat jouw tik landt, een sessieledger die oude screenshots comprimeert tot visuele samenvattingen, en twee uitvoeringsprofielen — Flash met ongeveer 3–5 seconden per stap, Pro met ongeveer 15–40 seconden per stap met een Planner, een Operator en een read-only Checker. Alles wat het over de wereld weet, komt binnen via een visie-taalmodel dat het niet zelf heeft geschreven.

Gemma 4 12B is het tegenovergestelde soort object. Het is een checkpoint. Het heeft geen apparaatverbinding, geen ADB, geen toegankelijkheidsservice, geen besef dat een tik iets is dat uitgevoerd kan worden. Geef het een schermafbeelding en vraag wat er vervolgens moet gebeuren, en het zal je antwoorden — mogelijk zelfs goed — maar het antwoorden is de volledige reikwijdte van zijn handelingsvermogen. Alles tussen "het model zei: tik op (540, 1180)" en "de telefoon tikte op (540, 1180)" is de taak van ARTEMIS, en dat is het grootste deel van het werk.

Dus de eerlijke framing van deze confrontatie is niet ARTEMIS-versus-Gemma. Het is: wat levert een open 12B-model je op als redeneerlaag van een Android-agent, en wanneer moet je betalen voor iets groters?

Wat Gemma 4 12B daadwerkelijk brengt

Voor een middelgroot model is het ongewoon goed gespecificeerd, en drie van zijn eigenschappen zijn van belang voor alles wat mobiel is.

• Het is op de invoerlaag echt multimodaal. Tekst, afbeeldingen, audio en video gaan erin; tekst komt eruit. Het is de eerste middelgrote Gemma zonder afzonderlijke multimodale encoders, en de eerste in de familie die audio native kan verwerken — wat geen UI-automatiseringsfunctie is, maar wel een echte als je testscenario's spraakberichten, meldingen die spreken of toegankelijkheidstrajecten op basis van audiosignalen omvatten.

• Het is een 12B-model dat je kunt vasthouden. Artificial Analysis vermeldt het als 12B totaalparameters onder Apache 2.0 — geen omzetdrempel, geen onderzoeksclausule, een licentie waarop je een product kunt bouwen zonder het iemand te hoeven vragen — met een contextvenster van 256K, redeneren ingeschakeld, en een gemeten outputsnelheid van 109,2 tokens per seconde. Volgens meldingen uit de community zijn de gewichten ongeveer 13,4 GB groot bij SFP8 en ongeveer 6,7 GB bij Q4_0, wat neerkomt op een laptop met 16 GB geheugen.

• Het is goedkoop, maar niet het goedkoopste in zijn klasse. Artificial Analysis vermeldt het tegen $0,10 per miljoen invoertokens en $0,30 per miljoen uitvoertokens — en merkt in hetzelfde paneel op dat dit aan de dure kant is voor een open-weights-model van vergelijkbare grootte, waar de mediaan op $0,05 in en $0,15 uit ligt. Cache-reads kosten ongeveer $0,03.

Het benchmarkbeeld is de gebruikelijke middenklasse-warboel en verdient een zorgvuldige formulering, omdat de cijfers op de trackersites van elkaar verschillen. Artificial Analysis geeft de reasoning-configuratie een Intelligence Index van 14, waarmee hij 21ste staat van de 142 open-weightmodellen in zijn klasse — een respectabele positie in de middenmoot en een heel eind van de frontier verwijderd. Google's eigen positionering is dat de 12B bijna net zo goed presteert als de grotere Gemma 4 26B-A4B en de Gemma 3 27B van de vorige generatie verslaat op het gebied van redeneren, wetenschap en documenten. Aggregatoren van derden zetten het op ongeveer 72% op LiveCodeBench v6 en 77,2% op MMLU-Pro, met GPQA Diamond variërend van 66% tot 79%, afhankelijk van welke tracker en welke configuratie je bekijkt. Dat zijn respectabele cijfers voor een 12B. Het zijn ook niet-geauditeerde, zelfgerapporteerde aggregaten, en waar vier sites dertien punten uit elkaar liggen, moet je de range aanhouden in plaats van het punt.

Wat ARTEMIS brengt, in één alinea, omdat het hier niet het onderwerp is

ARTEMIS brengt alles wat het model niet kan: een dynamic-first-locator die indices van toegankelijkheidselementen gebruikt wanneer die bestaan en terugvalt op vision en coördinaten wanneer dat niet het geval is, wat betekent dat er geen XPath te onderhouden is en geen ID's verouderen op een Compose- of Flutter-oppervlak. Het brengt een Safety Net dat de systeem-popup onderschept waarop je tik op het punt stond te landen, checkpointverificatie met vier niveaus van code>off/code> tot code>strict/code>, automatische crash-stacks, keyframe-screenshots en diagnoserapporten, een webconsole, een Python SDK voor pytest en CI, en — de reden dat het zich zo snel verspreidde — een native MCP-server die het geheel als vijf tools beschikbaar maakt voor Antigravity, Claude Code, Codex en elke andere MCP-compatibele assistent. Het geclaimde voltooiingspercentage van 99%+ op de AndroidWorld-benchmark van Google Research zet ARTEMIS op 99,1% op het publieke leaderboard per 11 september 2026, tegen 80% voor menselijke prestatie. Dat cijfer is zelfgerapporteerd en het leaderboard verifieert inzendingen niet, dus beschouw het als een sterke leveranciersclaim in plaats van een audit.

De enige plek waar de twee echt overlappen

Er is een echte architectuur waarin een kleine Gemma het hele werk doet, en het is de moeite waard om ernaar te kijken, want ze laat zien waar het cloudmodel eigenlijk voor betaalt. Een open-source Android-agentframework genaamd Orion draait volledig op het toestel: MediaProjection legt het scherm vast, een gekwantiseerd Gemma-4-E4B-it dat via LiteRT-LM op de Qualcomm Hexagon NPU draait, kiest de volgende actie, en de Android Accessibility Service verstuurt de tikken. Geen cloud-API, geen rekening per token, en het scherm verlaat nooit het toestel. Het is gevalideerd op een Galaxy S25 Ultra en is volgens zijn eigen beschrijving alleen zinvol op hardware met een Hexagon NPU — het model heeft ongeveer 3 GB opslag nodig en het framework richt zich op QNN HTP v79 op arm64.

Dat is de vorm van een Android-agent met een klein model die vandaag werkt, en let op wat het kost om daar te komen. Het model is gequantiseerd en op de NPU gemapt. De actieruimte bestaat uit pixels, omdat een model dat alleen op screenshots werkt "element index 12" niet kan interpreteren. Het hele ontwerp is een verticale stack — model, runtime, silicium, framework — en daarom is het een framework en geen drop-in voor je testsuite. Gemma 4 12B heeft ongeveer drie keer zoveel parameters als de E4B in die stack en wordt niet geleverd in een formaat dat op een telefoon kan draaien; een 12B met vierbitskwantisering is een workstation of een geserveerd endpoint, niet iets dat resident op een NPU is.

Waar elk daadwerkelijk wint

• Kosten op schaal — een zelfgehoste Gemma 4 12B heeft helemaal geen prijs per token, tegenover een vision-aanroep per stap voor elke stap van een ARTEMIS-run. Bij een regressiesuite van 500 tests die elke nacht draait, telt dat verschil sneller op dan welk benchmarkverschil dan ook.

• Privacy — Gemma 4 12B op je eigen hardware stuurt nooit een schermafbeelding ergens naartoe; de toegankelijkheidshelper van ARTEMIS draait expliciet op het apparaat zelf en verstuurt niets, maar de modelaanroep die hij bij elke schermafbeelding doet, gaat naar de provider die je hebt geconfigureerd.

• Taakbetrouwbaarheid bij een echte app — ARTEMIS, met een ruime voorsprong, omdat het een harnas met een vangnet is, met checkpointverificatie en herstel. Niets aan een beter model kan dat vervangen.

• Audio en lange documenten — Gemma 4 12B, met native audio-invoer op het technische specificatieblad en een contextvenster van 256K tokens. ARTEMIS heeft over geen van beide een mening.

• Tijd tot de eerste geslaagde test — ARTEMIS, met een enorme marge. Kloon code>./start.sh/code>, sluit een apparaat aan met USB-foutopsporing, wacht tot de eerste taak de toegankelijkheidshelper installeert. Het equivalent bouwen met een bare checkpoint is een project van meerdere maanden, en het Orion-voorbeeld hierboven is hoe dat project eruitziet wanneer het klaar is.

• Vrijheid om de redeneerlaag aan te passen — Gemma 4 12B, Apache 2.0-gewichten die je kunt fine-tunen op je eigen UI-vocabulaire. ARTEMIS is Apache 2.0-code, maar het redeneren gebeurt waar je model zich ook bevindt.

De versies van deze combinatie die vandaag daadwerkelijk beschikbaar zijn

Wees duidelijk over wat je deze week kunt uitrollen. De geteste backendlijst van ARTEMIS is Gemini, Claude, GPT-4o en Qwen-VL — Gemma 4 12B staat er niet op, en er is geen gepubliceerde evaluatie van Gemma 4 12B die een ARTEMIS-sessie aanstuurt. Het configuratiebestand accepteert een model-endpoint, dus de koppeling is eerder aannemelijk dan bewezen, en als je het probeert, doe je origineel werk in plaats van documentatie te volgen. Het is de moeite waard om ronduit te zeggen: de roadmap van ARTEMIS bevat een item "lichtgewicht VLM's op het apparaat", en het model dat die plek invult, zal geen 12B zijn.

Gemma 4 12B staat ook niet in onze catalogus — we routeren de andere Gemma 4-formaten, Gemma 4 26B-A4B en Gemma 4 31B, en niet de 12B, dus als dat het checkpoint is dat je wilt, haal je het uit de eigen distributie van de leverancier en de gebruikelijke third-party hosts. Waar een gerouteerde catalogus voor dient, is de andere helft van dit probleem: als je plan ARTEMIS op een gehost visiemodel is, is dat model een kostenpost die meeschaalt met elke stap van elke run, en de nuttige hefboom is niet de adviesprijs maar de cacheprijs. Een Pro-run leest bij elke stap een groeiende context opnieuw, dus een model met een goedkope cache-read verandert de rekensom veel meer dan een model met een goedkope nieuwe input. Dat is ook waarom provider-failover in de config thuishoort en niet in je incidentlog — een lange Android-sessie houdt zijn context op één endpoint, en een hapering bij de provider bij stap 74 kost je de run.

Welke is jouw volgende zet?

Als je een mobiele app en een regressiesuite hebt, wil je ARTEMIS, en Gemma 4 12B is geen vervanging voor welk onderdeel daarvan dan ook — het is op zijn best de engine die je later zou kunnen inwisselen, ongedocumenteerd, in je eigen tijd. Als je een product bouwt dat op een mobiel toestel moet draaien zonder netwerk en zonder kosten per aanroep, wil je een klein model, en Gemma 4 12B is waarschijnlijk te groot voor de vormfactor die je daadwerkelijk hebt; kijk naar wat Orion deed met een Gemma uit de 4B-klasse op een NPU voordat je aanneemt dat een 12B past.

De twee beslissingen botsen slechts op één punt, en het is een kostenkwestie in plaats van een capaciteitskwestie: hoeveel vision-aanroepen per dag ben je bereid te kopen? Beantwoord dat eerlijk — tel je tests, tel je stappen, tel je nachtelijke runs — en de keuze tussen een harness op een gehost model en een self-hosted stack maakt zichzelf.

Waar een gerouteerde catalogus voor dient, is de andere helft van dit probleem: als je van plan bent ARTEMIS op een gehost vision-model te gebruiken, is dat model een kostenpost die meeschaalt met elke stap van elke run