Does Vast-10M's 10-Million-Token Context Window Work in Practice?

Does Vast-10M's 10-million-token context window work in practice?

Mostly yes, with caveats. In one hands-on review, Vast-10M handled a roughly 4 MB legal corpus well, produced an acceptable HTML illustration, and delivered a clean 81-row multilingual table. It failed an hour-long agentic game build, which shipped without a visible player character. The long-context retrieval looked real. The agentic reliability and the reasoning traces looked less settled.

What is Vast-10M?

Vast-10M is a family of long-context models from a developer referred to as Waltropy in the review. Instead of training from scratch, the team took three existing open models and swapped their attention layers for VSA. The result is three variants, each with 10 million tokens of native context:

The reviewer received API credits from the developer. The review was not sponsored, and the developer asked for nothing beyond an objective assessment. That is worth knowing, but it does not change what the tests showed.

How does VSA replace attention?

Standard attention compares every token with every other token, so cost grows quickly as context gets longer. That is the main reason most models stop at a few hundred thousand to a million tokens. VSA is the developer's own attention replacement, billed as a scalable alternative.

The technical report claims two things. First, it reaches 10 million tokens. Second, it scores higher at shorter contexts, and it does this without extensive retraining of the base models. That second claim matters. It suggests the swap does not wreck what the original models already learned.

What is missing is detail. The reviewer found little specific information on how VSA works beyond a few paragraphs in the report, and called for more disclosure or open weights. Until then, treat the mechanism as a black box and judge the model on outputs.

How did Vast-10M do on an agentic game build?

Poorly. The first test asked the model to build a complete 3D "floor is lava" game from nothing. The brief called for Blender scripts for the furniture and lava, Godot 4 for gameplay, a timer, a start screen and a game over screen. It is a long, multi-tool job, and the reviewer said only one other model had handled it decently.

The run took almost an hour and produced a lot of files, plus a headless result with some tests. But when launched, the reviewer saw no character jumping on screen. Some methods were missing, and the reviewer had to import them manually. After that, jumping and movement worked, but no character appeared on screen. The reviewer called it a fail. A task that long should end in a complete result without rescue.

This test used the Hermes agent harness. Some of the failure could come from the harness or the engine setup rather than the model. Even so, the model reported success on something that did not visibly work.

Can it produce detailed visual work from one prompt?

Adequately. The second test asked for an intricate biker tattoo on a realistic forearm as a single self-contained HTML file. This is not image generation. The model had to draw everything in code.

The page loaded without errors and included several requested elements:

• A skull, crossed pistons, three roses and a red flame cluster
• A mandala at the top
• A "ride or die" banner on a dark background

The skin tone and shading gave a believable sense of depth, and the roses were the best part. The weak spots were a simple skull without the requested winged crown and wings, a snake that looked like a loose black coil without clear scales, and some banner text overlap. The reviewer marked it a pass, as a decent first draft that falls short of the intricate design requested.

Does the 10M window hold up on a real legal corpus?

This was the strongest result. The reviewer uploaded seven volumes of Australia's Corporations Act, about 4 MB of text, to the developer's hosted platform. It was not one of the curated demos. The question was hard on purpose: it forced the model to connect sections across the whole act. The reviewer then spot checked a cited section number, section 1841, against the real law.

The final answer was good. It was well structured, followed the groupings in the prompt, and flagged what it could not find rather than guessing. A spot check of one cited section matched the actual text.

The reasoning trace was messier:

• It looped, repeatedly checking which files were loaded.
• It confused file names, such as volume 02 versus volume 03.
• It admitted to reconstructing a passage from memory, then said the passage was present in the text without proof.

So retrieval and synthesis worked, but the visible reasoning was not something to trust. If you build on this, verify citations programmatically instead of relying on the model's own claims of having checked.

Note the scale as well. 4 MB of text is a meaningful test, but it sits well below the 10 million token ceiling. This run shows the model is useful on a large document set. It does not show behavior at the full limit.

Is it creative and consistent across 81 languages?

Partly. The prompt asked for a culture-specific dating app name in each of 81 languages, with strict no-repeat rules. It also tested whether the model would admit what it did not know.

The format was perfect: one clean table, all 81 rows, no extra text. The model honestly flagged two languages it was unsure about, which is rare. It also gave translations for some entries, and many picks looked strong.

The failure was the closing claim that no two names shared the same root or idea. That was false. The reviewer spotted at least nine rows that essentially meant "love," including Pashto, Latin and Esperanto, and "longing" repeated often. Some names also looked doubtful, especially for low-resource languages. Native speakers would be the right judges there.

Summary of results

Should you build on Vast-10M?

It depends on the job. For large-document question answering, the legal result is encouraging, especially the habit of flagging gaps. For long autonomous coding runs, this review gives reasons for caution. Four tests are a small sample, and no benchmark numbers were independently verified here. The 1M-token comparison in the technical report remains the developer's own claim.

The reviewer said it would be good to get more information on VSA and to see the model open sourced or released as open weights. Running your own evaluation on your own documents is the only reliable check.