The biggest theme in this week’s AI model releases is not just bigger models—it is bigger working memory. Multiple new or recently released models now advertise context windows around one million tokens, while the coding-focused entrants are settling into the 262K-token range, enough to handle substantial repositories, documentation sets, and multi-file engineering tasks in a single prompt.
That shift matters because long-context models change the shape of practical AI use: instead of carefully excerpting a few files or documents, users can increasingly ask models to reason across whole systems. The caveat is equally important: large context windows improve access to information, but they do not automatically solve retrieval accuracy, instruction following, latency, cost, or hallucination.
| Model | Provider | Context | Pricing | Key Capabilities |
|---|---|---|---|---|
| GLM-5.2 | Zhipu AI / Z.ai | 1,048,576 tokens | Not specified in release data; check OpenRouter/Ollama provider listing | Long-context reasoning, text generation, coding |
| Fugu Ultra | Sakana AI | 1,000,000 tokens | Not specified in release data; check OpenRouter listing | Long-context reasoning, general-purpose text generation |
| NVIDIA Nemotron 3 Ultra 550B A55B | NVIDIA | 1,000,000 tokens | Not specified in release data; check OpenRouter/Ollama provider listing | Long-context reasoning, text generation, coding |
| Laguna XS 2.1 | Poolside | 262,144 tokens | Not specified in release data; check OpenRouter/Ollama provider listing | Code generation, long-context text workflows |
| Kimi K2.7 Code | Moonshot AI | 262,144 tokens | Not specified in release data; check OpenRouter/Ollama provider listing | Software engineering, code understanding, reasoning |
GLM-5.2: an open-weight 1M-token foundation model for reasoning, coding, and generation
GLM-5.2 from Zhipu AI / Z.ai is one of the most notable releases in this batch because it combines a 1,048,576-token context window with open-weight availability. That puts it in a category that is still relatively rare: very-long-context models that can be run or integrated outside a purely closed API environment, depending on the deployment route and hardware constraints.
The model targets long-context reasoning, general text generation, and code-generation workloads. In practical terms, that means it is positioned for tasks such as reading large technical manuals, comparing many documents, analyzing large codebases, or maintaining continuity across extended agentic workflows. The extra context headroom is especially relevant for tasks where the answer depends on scattered details rather than a single passage.
Technically, the headline specification is the 1,048,576-token context length. The model is listed on OpenRouter and is also available through the Ollama library. It is open weight, though users should still verify the exact license terms, acceptable-use constraints, quantization options, and hardware requirements from the provider or distribution channel. The release data does not specify maximum output length, multimodal support, or pricing, so those should be treated as deployment-specific details rather than assumed capabilities.
The main benefit of GLM-5.2 is flexibility. Open-weight access makes it attractive for teams that want more control over inference environments, privacy boundaries, or customization pipelines. The long context also makes it a strong candidate for retrieval-light workflows where users want to provide the full source material directly.
The trade-off is that million-token prompting can be expensive and slow, even when a model supports it. Long-context reliability is also uneven across the industry: models may attend well to recent or prominent sections while missing details buried in the middle. GLM-5.2 should therefore be evaluated not just on maximum context length, but on needle-in-a-haystack retrieval, citation fidelity, coding correctness, and latency under realistic workloads.
Compared with smaller or shorter-context open models, GLM-5.2’s differentiator is scale of context. Compared with closed long-context systems, its appeal is likely to be deployment control and openness rather than guaranteed turnkey performance.
Fugu Ultra: Sakana AI enters the 1M-token general-reasoning tier
Fugu Ultra is Sakana AI’s long-context model listed on OpenRouter with a 1,000,000-token context window. Unlike the coding-specific releases in this roundup, Fugu Ultra is positioned as a general-purpose reasoning and text-generation model, making it relevant for broad analytical workflows rather than only software engineering.
The notable feature is straightforward: one million tokens of context. That is enough to ingest book-length material, extensive legal or technical corpora, long chat histories, or multi-document research packets. For users building research assistants, document analysts, or complex planning agents, that context size can reduce the need to aggressively chunk and summarize every input before the model sees it.
Its listed capabilities are long-context reasoning and text generation. The release data does not indicate open-weight availability; Fugu Ultra is marked as not open weight. It is available through OpenRouter, but maximum output length, modalities, and pricing are not specified in the provided release information. Readers should verify current rates and operational limits in the live provider listing before budgeting large-context workloads.
Fugu Ultra’s strength is its positioning as a broad reasoning model rather than a specialized coding assistant. If Sakana’s implementation handles long-range attention robustly, it could be useful for synthesis tasks where the model must compare arguments, track timelines, or reconcile details across many documents.
The obvious limitation is access and control. Because it is not open weight, users depend on hosted availability, provider terms, and API economics. Another caveat is that long context can create a false sense of completeness: just because a million tokens are present does not mean the model will use all of them equally well. For high-stakes tasks, users should still require grounded citations, intermediate reasoning checks, and targeted retrieval.
Relative to GLM-5.2 and Nemotron 3 Ultra, Fugu Ultra’s biggest distinction is that it is a closed, general-purpose long-context option. It may appeal to users who value managed access over local deployment, but it will need strong empirical performance to stand out in an increasingly crowded 1M-token field.
NVIDIA Nemotron 3 Ultra 550B A55B: a heavyweight open model with million-token reach
NVIDIA Nemotron 3 Ultra 550B A55B is another major entry because it brings the Nemotron family into the million-token context tier while remaining open weight. The model is listed on OpenRouter and available in the Ollama library, giving it visibility across both hosted routing and local-model ecosystems.
The name indicates a very large 550B-class model, with the “A55B” designation suggesting an active-parameter profile typical of sparse or mixture-style architectures, though users should confirm the exact architecture in NVIDIA’s technical materials. Its intended workloads include long-context reasoning, general text generation, and code generation.
The core specification is a 1,000,000-token context window. Like the other models in this roundup, the provided release data does not specify maximum output length, pricing, or non-text modalities. It is open weight, but license details and practical deployment requirements matter substantially here: a model of this class may be open, but not necessarily easy or inexpensive to run at full capability.
The biggest strength of Nemotron 3 Ultra is that it combines scale, openness, and a broad capability profile. NVIDIA’s models are often evaluated by enterprise and infrastructure-focused users who care about throughput, deployment control, and integration with accelerated inference stacks. For organizations already invested in NVIDIA hardware, Nemotron-family models may be particularly interesting.
The limitations are practical. Large open-weight models can impose significant hardware, memory, quantization, and serving complexity. Million-token context also magnifies those costs. Users should benchmark smaller prompts, long-context retrieval, coding accuracy, and concurrency before assuming that the maximum context window is economically usable in production.
Compared with GLM-5.2, Nemotron 3 Ultra appears positioned more as a heavyweight infrastructure model. Compared with Fugu Ultra, its open-weight status is the major differentiator.
Laguna XS 2.1: Poolside’s 262K-token model for long-context coding and text
Laguna XS 2.1 from Poolside is smaller in context than the million-token models above, but its 262,144-token window is still substantial—especially for software work. It is listed on OpenRouter and available in the Ollama library, and it is open weight.
The model is aimed at code generation, long-context workflows, and text generation. A 262K-token context can often fit a meaningful slice of a repository, including source files, tests, configuration, documentation, and recent issue context. For many coding tasks, that may be more practical than a million-token model if latency and cost are lower.
Technical details available from the release data include the 262,144-token context length, open-weight status, OpenRouter listing, and Ollama availability. Maximum output length, pricing, license specifics, and modality support are not specified here. Based on the listed capabilities, users should treat it primarily as a text/code model.
Laguna XS 2.1’s strength is focus. Poolside is associated with software engineering models, and a coding-oriented 262K context window is a useful middle ground: large enough for serious repository understanding, but potentially more efficient than ultra-long general models.
The limitation is that coding performance depends heavily on benchmarked correctness, tool use, test awareness, and edit quality—not just context size. Users should evaluate it on multi-file refactors, bug localization, test generation, and build-error repair before adopting it for autonomous coding workflows.
Kimi K2.7 Code: Moonshot’s long-context coding specialist
Kimi K2.7 Code is Moonshot AI’s coding-focused model with a 262,144-token context window. Like Laguna XS 2.1, it is available via OpenRouter and Ollama and is marked open weight.
Its listed capabilities are code generation, long-context reasoning, and software engineering-oriented understanding. That makes it relevant for tasks such as reading large repositories, explaining unfamiliar systems, generating patches across multiple files, or reasoning about dependency and API interactions in a codebase.
The main specs are a 262K-token context, open-weight availability, and code-focused capability profile. Pricing, maximum output, exact license terms, and modality support are not specified in the release data.
Kimi K2.7 Code’s benefit is specialization. Compared with general-purpose million-token models, a dedicated coding model may provide better completions, more idiomatic patches, and stronger reasoning about program structure—assuming Moonshot’s training and evaluation support those strengths.
Its caveats are familiar: code models can produce plausible but broken changes, miss hidden constraints, or overfit to visible patterns. Human review, test execution, and constrained editing workflows remain essential.
A practical note for software maintenance
Long-context and coding-focused models are increasingly useful for maintenance tasks such as dependency auditing, changelog summarization, version-drift detection, and repository-wide impact analysis. The best use is not to hand full control to a model, but to let it read more surrounding context, propose hypotheses, identify affected files, and explain likely upgrade risks. For production workflows, pair model output with deterministic tooling, tests, lockfile checks, and human review.
Bottom line
This week’s releases show long context becoming a standard competitive frontier rather than a niche feature. GLM-5.2 and Nemotron 3 Ultra stand out for combining open-weight access with million-token windows, Fugu Ultra adds another closed long-context reasoning option, and Laguna XS 2.1 plus Kimi K2.7 Code push repository-scale coding workflows forward.
The next phase will be less about who advertises the largest context window and more about who uses that context reliably, efficiently, and verifiably. Expect the strongest models to differentiate on long-context accuracy, tool integration, latency, cost control, and the ability to turn massive inputs into grounded, testable outputs.