Running Qwen3.8-Flash-Next on Strata and Having OpenCode Build Three Things

I ran the 125B MoE open model, “Qwen3.8-Flash-Next,” via Strata on a Windows PC with a single RTX 4090, then tried using it as OpenCode’s implementation agent.

I tested it on three projects: a Three.js 3D game, a practical web app, and a 30-second motion-graphics video. The short version: the game and web app succeeded. The video was generated, but its visual quality still has a long way to go.

This is not a rigorous benchmark, but a highly subjective real-world work test.

Test Environment

Item	Configuration
GPU	NVIDIA GeForce RTX 4090 24GB
CPU	Intel Core i7-13700K (16 cores / 24 threads)
RAM	64GB
OS	Windows 11 Pro
Inference	Strata v0.1.40.2 / Qwen3.8-Flash-Next IQ2_XS
Context	262,144 tokens
Coding agent	OpenCode v1.17.13

The model itself is about 70GB. On the 4090, short responses ran at roughly 86–108 tok/s, while even long 32K–128K prompts loaded at around 4,400–5,000 tok/s. I was also able to process 255K tokens in practice.

However, the biggest constraint was RAM rather than VRAM. Since Strata uses a substantial amount of memory, running Docker, Next.js builds, Playwright, and other tools concurrently on the same 64GB machine becomes quite difficult. If you want to develop seriously in parallel, 96GB or more—or separate machines for inference and development—seems more realistic.

1. A Three.js 3D Game: Success

First, I had it build a 3×3×3 “3D version of Lights Out” in Three.js. The single prompt included neon visuals, bloom, sound effects, Japanese and English UI, Undo, and a level-clear sequence.

The tech stack was a single HTML file and Three.js. The implementation totaled 559 lines, combining rendering, post-processing, Web Audio, and mouse controls. It generated roughly 31,000 tokens, and took about five minutes.

When checked in headless Chrome, there were zero JavaScript errors. Clicking, rotating the view, and clearing the level all worked in practice.

There was one flaw: the board-generation logic differed between level creation and reset. However, because every configuration of this 3×3×3 board is mathematically solvable, the game itself cannot become unwinnable.

• Subjective success rate: 90%
• Time required: about 5 minutes
• Assessment: Very good for a one-shot generation. Both the visuals and behavior are sufficiently polished to feel like a complete piece

2. A Fairly Full-Featured Web App: Success

Next was “ORBIT,” a studio booking-management console. Rather than a simple dashboard, I had it build a 12-screen, roughly 5,700-line Next.js application.

The tech stack was Next.js 16.4 (App Router / TypeScript), Tailwind CSS, Prisma 6.19, SQLite, recharts, date-fns, zod, jose, and bcryptjs. It implements login, monthly, weekly, and daily calendars, booking management, customers, rooms, staff, invoices, reports, and settings.

The initial autonomous development took 62 minutes. However, 37 of those minutes were spent stuck on a smoke test that never finished, so the LLM’s actual working time was about 25 minutes. All 12 screens were in place 26 minutes after starting. The initial development alone generated 157,000 tokens.

In final validation, 24 of 25 E2E checks passed. TypeScript, the build, linting, and smoke tests also passed. It fixed 7 of the 8 requested corrections.

On the other hand, it initially reported that “all requirements passed” despite remaining lint errors. One instance of horizontal scrolling also remains in the mobile view. You cannot take its self-reports at face value; an independent test reviewer is necessary.

The other failure was the PostgreSQL + Docker setup. With 64GB of RAM, there was not enough headroom to run Strata, Docker, and builds simultaneously, so I ultimately switched to SQLite. The agent was also forcibly terminated twice due to insufficient memory.

• Subjective success rate: 95%
• Time required: about 62 minutes (about 25 minutes of actual work) + about 30 minutes of fixes
• Assessment: At minimum, it appears capable of building a typical web app end to end

3. Motion-Graphics Video: Generation Succeeded, Quality Still Has a Long Way to Go

Finally, I had it create “STRATA // SIGNAL,” a 30-second 4K motion-graphics piece synchronized to music.

The tech stack was Python, Skia, NumPy, SciPy, Pillow, and FFmpeg. It generated not only the visuals but also a 128 BPM, 16-bar algorithmic music track in code. The completed file is 3840×2160 at 30fps, with 900 frames and a duration of 30.000 seconds. The audio is stereo 48kHz at -14 LUFS.

It took about an hour and a half from the start to the completed 4K output. Along the way, there was a session that repeated the same reasoning until reaching the 32K output limit, a session where OpenCode froze for 13 minutes after launch, and an out-of-memory termination during final rendering. The 4K render itself took about 11 and a half minutes.

It works as a video file. However, the specified neon rings and streaks are barely visible in 4K, and the overall image is dark. The grainy noise is too strong, scene changes are weak, and synchronization between the visuals and beat is difficult to perceive. It deserves credit for independently producing a 30-second 4K video with audio, but it is hard to call the creative quality acceptable.

• Subjective success rate: 50%
• Time required: about an hour and a half
• Assessment: It can build a generation pipeline. But the visual direction needs human review and multiple rounds of revision

Summary: Probably the Strongest Open Model Yet That Can Run on an RTX 4090

This is extremely subjective, but among open-source models that can run on an RTX 4090, Qwen3.8-Flash-Next is probably the strongest I have used so far.

It is especially strong at web-app development. Give it a specification and it can plan, implement, build, and test an app with many screens. Of course, you should not trust its claim that it is “done”; independent validation is essential. Even so, it is honestly impressive that a local model alone can do this much.

In terms of feel, it is about as practical as Sonnet was—though I forget which version—back when Opus was expensive and not something you could casually use. The game was also quite good. On the other hand, tasks such as motion graphics, where there is a large gap between code that works and something that is genuinely good as a finished piece, still need further testing.

And the biggest problem this time was not the model’s intelligence, but 64GB of RAM.

Local LLMs really are evolving.