This Open Model Thought for 88,000 Characters… and Wrote Zero Code

Author: Prompt Engineer 48 · Watch on YouTube

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: This Open Model Thought for 88,000 Characters… and Wrote Zero Code · Channel: Prompt Engineer 48 · 10:28 · Watch on YouTube

Topics: AI agents, Software engineering with AI, Local and open-source models, Multimodal models

Summary

The video tests the open-weights Next N 2.5 mini model, running a Q8 GGUF on a rented A100 GPU, across coding, vision, long-context, tool-use, and reasoning tasks. It reads charts accurately, handles long-context retrieval and a tool-using coding agent well, and can produce strong code when given a large thinking budget. However, adaptive thinking often runs out of tokens, while turning thinking off leads to fast but error-prone results; visual self-correction also fails to fix a dashboard and a game. The reviewer concludes that the model is promising for document reading and agent workflows, but its self-correction should not yet be trusted.

Key points

The Q8 model and vision projector loaded on an A100 80 GB, using 41.8 GB of VRAM with the full 262,000-token context.
Generation reached about 126 tokens per second on long outputs, with prompt processing between 700 and 3,000 tokens per second.
With default adaptive thinking, several open-ended coding tasks consumed tens of thousands of reasoning characters and returned no code.
Turning thinking off produced a polished galaxy page quickly, but the canvas was black until the model diagnosed and fixed a WebGL bug.
With a 110,000-token thinking budget, it generated a working galaxy visualization with 90,000 stars.
It extracted all 61 numbers from its benchmark chart correctly and found all three long-context needles.
Screenshot-based computer-use grounding scored four out of five; one response ignored the requested coordinate scale.
The visual self-correction loop accurately described dashboard problems but failed to fix them, and repeated attempts did not make the game demo work.
A tool-using coding agent fixed a failing test and broken build configuration, then verified that both passed.
Thinking mode solved the tested algorithm and logic puzzle correctly, while thinking-off answers were wrong; the model also refused to fabricate details about a fake study.

Chapters

Start	Chapter	Summary
00:00	Model, setup, and test plan	The reviewer introduces the model, rents an A100, loads the Q8 version, and outlines the 11-test gauntlet.
02:39	Galaxy coding and thinking budgets	Open-ended coding overwhelms default thinking, but the model can fix a WebGL bug and produce a working galaxy with a larger budget.
04:13	Vision and visual self-correction	The model reads a benchmark chart perfectly and performs mostly well at screenshot grounding, but struggles to reproduce layouts and repair a dashboard.
06:20	Game, agent tools, and reasoning tests	The game remains broken after repeated repair attempts, while the agent loop, long-context retrieval, and thinking-enabled reasoning tests show stronger results.
08:23	Scorecard, cost, and verdict	The reviewer summarizes the model’s strengths and limitations, reports the GPU bill, and advises against trusting its self-correction patches.

Quotes

It thought for 88,000 characters and wrote zero lines of code. — 00:00

One bug shipped, one bug self-fixed. — 03:40

And this time it shipped working code on the first try. — 04:13

It can see the bug, it couldn’t fix it. — 06:20

Just don’t trust the self-correction patch yet. — 10:28

Concepts and entities

Next N 2.5 mini, Next AGI, Qwen3.5, Claude Code, RunPod MCP server, llama.cpp, GGUF, autocorreção visual, A100

Full transcript (original language)

00:00 I gave this open model 32,000 tokens to build a 3D galaxy. It thought for 88,000 characters and wrote zero lines of code. Then I turned thinking off and it shipped a galaxy in 45 seconds that rendered a completely black screen. So, is Next N 2.5 mini actually good? I rented a GPU with an MCP server, ran it at full Q8 quality, and put it through 11 hard tests. Some results are genuinely impressive, some are not. Next N 2.5 mini is from Next AGI. It’s an

00:32 open weights Agentech model built on the Qwen 3.5 mixture of experts architecture with a 262,000 token context window and vision input. The authors pitch it for coding tool use, computer use, and something they call self-correction through visual feedback where the model looks at a screenshot of its own work and fixes it. Their benchmark table makes big claims. 82.9 on OS World G, which is clicking the right element in a screenshot, and that’s higher than Claude Opus 5 on that chart. 89.7 on Omni dog for reading

01:05 documents. 73 on terminal bench. But, these are the full precision model in their own harness. I wanted to know what you get from a quantized GGUF on a single rented GPU. First, the GPU. Instead of clicking around a website, I asked Claude code to rent it for me using the RunPod MCP server. It listed every GPU with at least 48 GB, checked live capacity, and picked an A100 80 GB in secure cloud at $1.59 I gave it one safety rule. If the price

01:35 comes back above 170, delete the pod immediately. The price came back at exactly 159 and the pod was running. Now, real life, my usual SSH key had a passphrase. So, I swapped the pod to a different key, which restarts it. The first llama.cpp build failed because the CUDA compiler wasn’t on the path and the system CMake was too old. After fixing that, the Q8 model 36.9 GB plus the Vision projector loaded in about 9 seconds using 41.8 GB of VRAM with the full 262,000 token context. And it is

02:08 fast. About 90 tokens a second on the very first call, around 126 tokens a second on long generations, and prompt processing between 700 and 3,000 tokens a second. For a model this capable on 1 A100, that’s excellent. Here’s the gauntlet, a WebGL Galaxy, a playable game rebuilding a website from a screenshot, a dashboard. It has to fix by looking at its own screenshots, reading its own benchmark chart, clicking targets in real screenshots, an

02:39 agent loop with tools, a needle in a 150,000 token haystack, a hard algorithm I actually execute, a logic puzzle, and an honesty trap. Every output here is real. Test one, and the first surprise, with default adaptive thinking, and a 32,000 token budget, the Galaxy prompt produced 88,000 characters of reasoning and then got cut off. No HTML at all. And it wasn’t a one-off. The website rebuilt did the same at 95,000

03:10 characters, the game at 76,000, and the algorithm at 109,000. On open-ended creative code, this model can think itself to death. So, I retried with thinking turned off. The Galaxy came back in 45 seconds, a polished page called Nebula Forge, 70,000 stars, no JavaScript errors, and a completely black canvas. The console showed WebGL errors index out of range. The model had passed a number into get a triple location instead of an attribute name.

03:40 This is where it gets good. I send the model its own error and the few lines of buffer code and ask for a minimal fix. It diagnosed it exactly, size is not an attribute name, so the lookup returns minus one. It used the shaders layout locations instead. I applied its fix and there it is. 70,000 stars in spiral arms, drag to orbit, scroll to zoom. One bug shipped, one bug self-fixed. Then I gave thinking mode a real budget, 110,000 tokens. It thought for 122,000

04:13 characters, wrote 56,000 tokens, took 7 and 1/2 minutes. And this time it shipped working code on the first try. NGC 7742, 90,000 stars, three arms, a temperature color scale, auto orbit, and a star count switcher running at 60 frames per second on my laptop. The default camera sits a bit too close to one arm, but it is genuinely beautiful. Now, the vision claims. I gave it the image of its own benchmark chart and asked it to extract every number as JSON. Nine charts, 61 numbers. It got

04:45 all 61 exactly right. That OmniDoc score is believable. Next, computer use grounding. Five real screenshots, find the element, and give a click point on a zero to 1,000 scale. On GitHub, it nailed all three, the star button, the green code button, and the issues tab. On Hacker News, the comments link of the first story was a hit right at the edge of the text. But for the login link, it ignored the zero to 1,000 scale entirely and answered with a number over a thousand, so the click falls off the screen. Four out of five.

05:17 And a quick confession, my own scoring bucks for that comments link was wrong at first. I caught it by checking the pixels and fixed the score. Screenshot to website with thinking on and overthought again. With thinking off, it rebuilt Hacker News in 35 seconds. Every story title, domain, point count, username, and comment count is correct, but the layout is off. Each story is split across four lines and the centered column is missing. Great at reading, weaker at reproducing layout. And this is the test that matters most for their

05:48 pitch, visual self-correction. With thinking on, its first dashboard looked strong, but when I fed it the screenshot, it over thought and ran out of tokens. So, I ran the loop with thinking off. It built a dashboard, I screenshotted it and fed the image back, and its description was accurate. About 440 pixels of empty space on the left, the chart clipped, the legend cut off. It saw every problem. Then it sent back corrected code, and the new screenshot had the exact same empty column. Round two, same diagnosis, same result. It can

06:20 see the bug, it couldn’t fix it. The breakout game was the hardest lesson. With thinking off, it shipped a slick neon game in 87 seconds, but the demo AI never played, and the canvas was tiny. I sent it the bugs four times round one. It found real problems and fixed the canvas size, but its fixed launched the ball in a way that switched the AI off. Round two, it blamed the wrong function, and to be fair, my own prompt mislabeled one line, which I corrected. Round three with thinking on, it thought for 127,000

06:50 characters and ran out of tokens. Round three with thinking off, it sent a patch containing code that can never run. Four attempts, and the demo still doesn’t play itself. The agent test went much better. A real node project with a failing test and a broken build, and three tools, run shell, read file, and write file. In seven turns, it explored the project, read every file, found that the test was missing its auth header, and that the build config didn’t exist. Fixed both, then ran the tests and the build to verify. Both passed. Tool calls

07:21 work natively through llama.cpp. Long context. I had a walled code at 37% depth inside 24,000, 97,000, and 151,000 tokens of filler. It found all three. The 151,000 token prompt was processed at over 2,500 tokens a second, 61 seconds end to end. The hard algorithm, maximum edge weight on tree paths with binary lifting for 200,000 nodes and queries. I ran every answer against brute force on 300 random

07:53 trees. Thinking off answered in 5 seconds and was wrong, 86 out of 300. Thinking on answered in under 4 minutes and was perfect, 300 out of 300. And solved the full-size test in 1.9 seconds. Same pattern on a logic puzzle about five people in a row. With thinking it correctly said the clues allow three different orders, which I verified by brute force. With thinking off it confidently announced there was only one possible order, wrong. And for the honesty trap, a fake Stanford study, it

08:23 refused to invent anything and asked for DOI, good. So, here’s the scoreboard. Clear wins, reading charts, 61 out of 61. Long context, three out of three. The agent loop, the algorithm with thinking, honesty, and speed. Mixed grounding at four out of five. The website rebuilt and the galaxy that needed one self-fix. Losses, five overthinking deaths at the default budget. Broken first drafts on visual code. A self-correction loop that describes problems but doesn’t fix them.

08:55 And a game it couldn’t repair in four tries. Pros, one, it’s fast, over 120 tokens a second on one A100. Two, excellent vision reading and document extraction. Three, long context that actually works. Four, a solid agent loop with native tool calls. Five, when it does think, the code quality is high. And six, it’s Apache 2.0 and the Q8 fits a single 80 GB GPU with the full context. Cons, one, adaptive thinking can burn 100,000

09:25 characters and never answer. So, you need big budgets or thinking off. Two, thinking off is fast but ships bugs and wrong answers. Three, visual self-correction. The headline feature didn’t work in my test. Four, it sometimes ignores output format rules like that coordinate scale. And five, this was a GGUF quant in llama.cpp, not their official harness, so your results may differ. And the bill, at the end, I asked Claude code to shut everything down through the MCP server again. It stopped the pod,

09:57 deleted it, confirmed zero pods were running, and pulled billing. $12.67 for about 8 GPU hours at 159. That’s more than I planned because I left the pod running through setup, build fixes, and long waits. Lesson learned, tear the GPU down the moment the tests are done. My verdict, Next 72.5 mini is a genuinely strong open model for reading long documents and agent tool use, and it’s fast for creative coding. Give thinking a large budget and expect to send it its own errors. Just don’t trust the

10:28 self-correction patch yet. Links to the model and the GGUF are in the description. Tell me what you [clears throat] want me to test next.