Local AI coding agents: a Tetris test shows today’s practical ceiling
On 16 May 2026, Jirka Herník ran the kind of test that is often more useful than another abstract benchmark table: six local models, one cloud baseline, and the same task for all of them. Write Tetris as a single HTML file.
The test ran on a powerful but still realistic home workstation: Ryzen 9 5950X, RTX 3070 with 8 GB VRAM, 128 GB RAM and LM Studio as the local server. The workflow used opencode as the coding agent, Playwright MCP for browser checks, and GPT-5.5 through OpenRouter as the reference cloud result.
Why this is a useful test
Tetris is not an enterprise app, but it is a better test than another TODO list. The model has to keep game state, rotations, collisions, rendering, timing, keyboard input and JavaScript errors under control. When the output must run as one HTML file, there is not much room to hide broken architecture.
Where the small models failed
The smallest models hit the wall quickly. According to the video, Nemotron 3 Nano 4B returned Python-like syntax inside JavaScript and ended at 0/11. Qwen 9B Q4 failed on a SyntaxError and also ended at 0/11.
That does not mean those models are useless. It means “local AI” is not one category. A model that works well in chat or on simple extraction tasks may still be a poor fit for a coding agent that has to create a functional interactive app.
Where local starts to become practical
The middle of the test is more interesting. Gemma 4 E4B reached 3/11 and Gemma 4 E2B reached 5/11, although the active block was invisible. That sounds funny, but it matters in practice: a local model may already be useful for drafts, small edits, simple refactors, code explanation, or first-pass implementation.
The standout local result was gpt-oss 20B. It reached 9/11 and produced an actually playable game. That is the point where a local model stops being only a toy. I still would not let it touch production code without review, but as a cheap first iteration layer it starts to make real sense.
Why the cloud baseline still won
GPT-5.5 through OpenRouter reached 11/11: ghost piece, 7-bag randomizer and wall-kick rotation. That is the difference between “it kind of runs” and “it understands the small application as a whole.”
The practical rule is simple: local models can be the cheap first layer, but hard cases, final review and more complex architecture still belong to a stronger model. Not because the cloud is magic, but because coding agents live or die by how many rules and edge cases they can keep in their head at once.
How I would use it in a workflow
I would use a local model today for:
- simple boilerplate,
- explaining unfamiliar code,
- a first draft of a small function,
- quick refactors without sensitive data,
- preprocessing work before a more expensive model.
I would keep a stronger model or cloud baseline for:
- architecture decisions,
- difficult bug fixes,
- tests and edge cases,
- final review,
- any situation where the cost of a mistake is higher than the cost of tokens.
Bottom line
This test is not about local AI losing. It shows that local AI is finally becoming practical, as long as it is placed correctly inside the workflow.
An RTX 3070 with 8 GB VRAM is still not a replacement for a frontier model. But it is already enough for a local agent to do the first chunk of work cheaply and without sending everything to the cloud. Production value does not come from one model writing Tetris. It comes from routing, tests, fallback and a human who can tell the difference between a playable demo and reliable software.
Sources: Jirka Herník: Tetris od 6 lokálních AI, LM Studio, opencode, Playwright MCP, OpenRouter, OpenAI: gpt-oss, Google Gemma, Qwen, NVIDIA Nemotron.