Rio 3.5 Open 397B: A Serious Open Model Release, Or A Benchmark Claim In Need Of An Audit?

Rio 3.5 Open 397B’s current model card warns that the earlier upload contained a base merged model rather than the final distilled model. The maintainers say they are working to reupload the correct model. Treat the earlier release analysis below as historical, and verify the corrected artifact before deploying or attributing benchmark results to it.

The analysis below was originally written for the June 14, 2026 release snapshot. Current repository update, October 9, 2026: the model card and README report an incorrect earlier upload and a pending corrected reupload. The current API lists 11 repository files and no weight shards, while its cached safetensors metadata and the retained index still describe the old tensor footprint. Those metadata alone do not establish that the intended distilled weights are downloadable. Historical specifications, benchmark tables and comparisons below are not revalidated performance results for a corrected release.

TL;DR

Rio 3.5 Open 397B was announced as a Hugging Face model under prefeitura-rio/Rio-3.5-Open-397B. The earlier snapshot recorded 97 safetensor shards, 110 repository files, 403,397,928,944 tensor parameters and an index total size of 806,795,875,168 bytes, or roughly 807 GB decimal / 751 GiB binary. The current API instead lists 11 files with no weight shards; the retained index and parameter metadata must not be treated as proof that a corrected model is available. Current metadata identifies the base model as Qwen/Qwen3.5-397B-A17B and retains an MIT license tag. The earlier model card attributed development to IplanRIO, the municipal IT company associated with Rio de Janeiro’s city government. Hugging Face model card, Hugging Face API, raw config, safetensors index

The headline claims are substantial: about 397B total parameters, about 17B active parameters, a sparse Mixture-of-Experts architecture, multimodal input, multilingual coverage, a 1,010,000-token context window, and first-party benchmark results that place Rio close to leading open and proprietary models. These were first-party claims in the earlier model card. The current card’s incorrect-upload notice means they must not be attributed to the earlier downloadable artifact as verified results. The earlier review recorded repository evidence for the weights, architecture, base-model relationship, modality configuration and a permissive license tag; it did not verify the intended final distilled artifact. I did not find independent Rio benchmark reproductions, a published Rio training report, or repo-local code implementing the claimed SwiReasoning inference path.

That makes Rio 3.5 Open 397B interesting, but not yet settled. Builders should first verify that the intended corrected weights have been released, then evaluate the first-party claims against that exact artifact. For broader context on choosing between closed, open, and local models, see Kingy AI’s guide: Which AI Model Should You Use?

Why This Release Matters

The unusual part is not just the scale. Open-weight MoE releases at hundreds of billions or trillions of total parameters are now part of the competitive landscape. Qwen, DeepSeek, Kimi, MiniMax, Meta, Z.ai/GLM, and others have already made large open or open-weight models central to the AI race.

The unusual part is the name on the repository. The earlier Rio model card identified the developer as IplanRIO – Empresa Municipal de Informatica e Planejamento S.A., which it describes as the municipal IT company of Rio de Janeiro’s city government. IplanRIO’s official site describes the organization as the municipal company responsible for administering the city’s information and communications technology resources. Rio model card, IplanRIO official site

That is a different release profile from the usual frontier-lab playbook. Frontier systems are normally launched by OpenAI, Anthropic, Google DeepMind, xAI, Alibaba/Qwen, DeepSeek, Moonshot, Meta, Mistral, MiniMax, or Z.ai. A city-government-associated technology company publishing a Qwen-derived, frontier-scale open-weight model is therefore notable even before the benchmark table enters the room.

It also lands at the center of a live strategic question: will the next useful AI stack be controlled mostly through closed APIs, or will open models become good enough for serious agentic software, government, and enterprise work? Kingy has covered that broader sovereignty question here: Open-source AI models, local LLMs, hardware, and AI sovereignty.

What Rio 3.5 Open 397B Is

The current model card describes a merge of Nex-N2-Pro and Qwen3.5-397B-A17B followed by on-policy distillation from a stronger model, and says the earlier upload was the base merged version rather than that final distilled model. The Rio README front matter lists base_model: Qwen/Qwen3.5-397B-A17B, and the Hugging Face tags include base_model:Qwen/Qwen3.5-397B-A17B. The text configuration is also structurally aligned with Qwen3.5: qwen3_5_moe_text, 60 layers, 512 experts, 10 selected experts per token, 4096 hidden size, 32 attention heads, and 2 key-value heads. Rio README, Rio config, Qwen3.5-397B-A17B card

In plain English, it is not a dense 397B model that activates every parameter for every token. It is a Mixture-of-Experts model. In an MoE model, many expert subnetworks exist, but only a subset is routed for each token. That is why the model card can claim roughly 397B total parameters and roughly 17B active parameters. Total parameters shape storage and memory requirements; active parameters shape part of per-token compute cost. Both matter.

Technical Specs

The context-window caveat deserves special attention. The earlier README listed a 1,010,000-token context window and gave vLLM/SGLang examples using 1,048,576 tokens. The current short README replaces those claims with the upload-correction notice; it does not establish the corrected model’s long-context behavior. But the actual config.json sets max_position_embeddings to 262,144. Qwen’s own Qwen3.5 card says Qwen3.5 “natively supports” up to 262,144 tokens and gives YaRN/RoPE-scaling instructions for reaching 1,010,000 tokens. That makes the safest interpretation: 262K is the native/configured context; roughly 1M is a long-context serving mode that likely depends on scaling overrides and memory budget. Rio README, Rio config, Qwen3.5 card long-context section

Benchmark Claims

The earlier Rio model card included the benchmark table transcribed below, covering agentic coding, software engineering, reasoning, math, multilingual, multimodal, instruction following, agents and an estimated economic-value benchmark. The current card no longer supplies that table. The locally retained graphic is historical first-party material; its upstream repository link returned 404 during this update.

Here is the core issue: benchmark numbers are not all equal. A number can be independently reproduced, benchmark-host reported, vendor reported, model-card-only, or copied from a comparison table with unclear harness settings. The historical Rio numbers below are first-party claims from the earlier card. The incorrect-upload notice makes exact model-artifact identity a prerequisite for any reproduction claim.

The benchmark families themselves are real. Terminal-Bench evaluates terminal agents in realistic command-line environments; SWE-Bench Verified is a human-validated subset of GitHub issue-resolution tasks; SWE-Bench Pro extends software-engineering evaluation to harder enterprise-style tasks; DeepSWE is a long-horizon software-engineering benchmark; and MCP-Atlas evaluates tool use across real MCP servers. Terminal-Bench, SWE-Bench Verified, SWE-Bench Pro, DeepSWE, MCP-Atlas

But a real benchmark is not the same thing as a verified score. A model-card table does not tell us whether the run used a standard scaffold, whether the same harness was used across models, whether tool access was comparable, whether contamination screens were run, whether the benchmark version was the same, or whether the reported comparison values came from benchmark hosts, vendors, or internal reruns.

Reported Gains Over Qwen3.5 Base

Within the historical Rio card, the most useful comparison was Rio versus its base model rather than every frontier model. Because the model claims to be post-trained from Qwen3.5-397B-A17B, the base-model delta is the natural place to look first.

The reported gains are large in some places: +18.3 on Terminal-Bench 2.1, +17.0 on DeepSWE, +19.8 on Apex, +8.6 on IMOAnswerBench, +7.8 on HLE, and +7.7 on SWE-Bench Multilingual. If independently reproduced, that would be a meaningful post-training result. But the word “if” is doing real work.

One Hugging Face discussion adds useful color. A user asked whether the Rio benchmarks were run with SwiReasoning active and whether the model would still improve without latent reasoning. A reply from Sangu1nius answered “With!” and gave an ablation-style mini-table: Qwen base at 80.9 on IMOAnswerBench, 50.9 on SWE-Bench Pro, and 9.4 on Apex; “+ Training” at 84.5, 54.8, and 22.9; and “+ Latent Reasoning” at 89.5, 58.1, and 29.2. That suggests the published Rio headline numbers may depend materially on the latent-reasoning inference path. HF discussion #2

That is important because not every inference stack can implement soft/latent reasoning. The same discussion explicitly notes that engines limited to discrete token generation, such as llama.cpp, cannot currently implement that style of continuous soft-embedding reasoning. HF discussion #2

SwiReasoning: What It Is, And What Is Actually Released

The earlier Rio model card said the model “features SwiReasoning,” a training-free inference framework from Shi et al. that switches between explicit chain-of-thought reasoning and latent-space reasoning. The arXiv abstract for SwiReasoning describes exactly that: dynamic switching between explicit and latent reasoning guided by entropy trends in next-token distributions, plus a switch-count control mechanism to reduce overthinking. The paper reports average accuracy gains of 1.8%-3.1% and token-efficiency gains of 57%-79% under constrained budgets across mathematics, STEM, coding, and general benchmarks. SwiReasoning arXiv, SwiReasoning GitHub

The idea is straightforward, at least at a high level:

• Explicit reasoning emits intermediate natural-language reasoning tokens. It is inspectable, but token-expensive.
• Latent reasoning keeps some reasoning in continuous hidden space or soft-embedding form. It may be more token-efficient, but it is harder to inspect and harder to support in ordinary inference engines.
• Switching tries to use entropy/confidence signals to decide when to explore in latent space and when to commit in explicit text.

The catch: the Rio repository files I reviewed do not include repo-local Python code implementing SwiReasoning. The current API lists 11 configuration, tokenizer, README and related metadata files, with no weight shards or .py files. The earlier review described a larger file list and serving examples; those observations belong to the old snapshot. The current generic Hugging Face usage snippets are not proof that a corrected model loads. That does not disprove that the model was trained to work well with SwiReasoning, but it does mean the integration is not self-evident from the released repository alone. Rio API, Rio README

For readers who want a fuller primer on reasoning tokens and chain-of-thought tradeoffs, see Kingy AI’s explainer: Chain-of-thought explained.

How It Compares To Frontier Labs

Rio’s first-party numbers suggest a model that may be competitive with leading open-weight systems and within striking distance of some frontier API models on selected rows. But frontier comparison is where benchmark hygiene matters most.

OpenAI’s GPT-5.5 page, Anthropic’s Claude Opus 4.8 page, Google’s Gemini 3.1 Pro model page, and xAI’s Grok 4 materials all publish their own benchmark packages, often with different benchmark versions, scaffolds, tools, and inference settings. OpenAI’s GPT-5.5 page, for example, reports Terminal-Bench 2.0 and SWE-Bench Pro values, while Rio’s card lists Terminal-Bench 2.1. Those are not automatically comparable. OpenAI GPT-5.5, Anthropic Claude Opus 4.8, Google Gemini 3.1 Pro, xAI Grok 4

The real comparison looks like this:

The intended benefit of an open-weight release is control: inspecting the config and, once the correct weights and applicable license are available, operating private infrastructure or adapting the model. The current Rio upload notice prevents assuming that the intended distilled artifact is ready for those steps. Frontier labs’ advantage is operational maturity: hosted reliability, safety/process documentation, product integrations, SDKs, tool ecosystems, and larger public testing footprints.

If you are building agents, that distinction matters. Agentic performance is not only “model IQ”; it is model plus tools, memory, sandboxing, retry logic, browser/terminal harness, context management, and eval discipline. Kingy has a broader implementation-oriented guide here: The state of AI agents in 2026, and an MCP-specific explainer here: What is Model Context Protocol?.

How It Compares To Heavyweight Open Models

Rio enters a crowded heavyweight open-weight field. The relevant peers are not only dense Llama-class models, but sparse MoE systems that try to combine huge total parameter counts with smaller active compute.

Sources: Rio model card, Qwen3.5-397B-A17B, DeepSeek-V4-Pro, Kimi-K2.6, MiniMax-M3, GLM-5, Meta Llama 4

Against those peers, Rio’s positioning is narrower than the model-card headline might imply:

• Versus Qwen3.5, Rio is best understood as a post-training and inference-strategy claim on top of the same base family. The reported gains over base are the key thing to reproduce.
• Versus DeepSeek-V4-Pro, Rio is smaller in total and active parameters, and its license tag is attractive, but DeepSeek’s own V4 card claims a much larger 1.6T/49B MoE and 1M context.
• Versus Kimi-K2.6, Rio is smaller and appears less obviously agent-productized. Kimi has a stronger public narrative around long-horizon coding and agent orchestration; Rio’s SWE-Bench Pro result is slightly lower than Kimi’s value in Rio’s own comparison table.
• Versus MiniMax-M3, Rio is similar in total-parameter class but lower in claimed active parameters. MiniMax emphasizes native multimodality and sparse attention for 1M context.
• Versus GLM-5, Rio is smaller and less documented, but potentially easier to reason about as a Qwen-derived release if the Qwen ecosystem supports it.
• Versus Llama 4, Rio is in a different open-weight lineage: Qwen MoE rather than Meta’s Llama MoE family. Llama’s ecosystem maturity remains a major counterweight.

Kingy has covered some of these peer families in more detail here: DeepSeek V4 deep dive, Kimi K2.6 analysis, and AI model picker.

Deployment Realities

The “17B active” number can be misleading if read casually. It does not mean Rio is as easy to run as a 17B dense model. Sparse MoE still requires the full expert weights to be present somewhere in the serving system. For Rio, the safetensors index alone reports about 807 GB of model data. Add KV cache, allocator overhead, tensor parallelism, communication overhead, and long-context memory pressure, and this becomes a serious multi-GPU or hosted-inference project.

The earlier README examples used --tensor-parallel-size 8 for vLLM and --tp 8 for SGLang. These are historical serving suggestions, not a test of the intended corrected model. That does not prove eight GPUs are always sufficient, because GPU type, precision, quantization, context length, batch size, and KV-cache strategy dominate the practical answer. It does, however, signal that the authors expect distributed serving. Rio README

Quantized derivatives may make experimentation easier, and Hugging Face search already exposes derivative quantized listings tied to the Rio base-model metadata. But quantization is not magic. It can reduce memory footprint, but long-context KV cache, expert routing, throughput, and quality degradation still need testing. Hugging Face quantized model search

Claim Audit

Bottom Line

Rio 3.5 Open 397B warrants follow-up, but its intended final artifact remains the first question: the current card disavows the earlier upload and says a corrected reupload is being prepared. If the reported post-training and SwiReasoning gains reproduce, it could be an important open-weight model for coding agents, multilingual work, and high-control deployments.

The next milestone is a clearly identified corrected release, followed by independent reproduction against that artifact. The earlier benchmark claims do not establish the performance of the incorrectly uploaded merged model.

After verifying the corrected artifact and its license, builders can use this evaluation plan:

1. Run a small, auditable subset of SWE-Bench Pro, SWE-Bench Verified, Terminal-Bench 2.1, and DeepSWE with a published harness.
2. Test Rio with and without SwiReasoning, because the discussion-thread ablation implies latent reasoning may account for a meaningful share of the gains.
3. Verify long-context behavior at 262K, 524K, and ~1M with retrieval, reasoning, and degradation tests.
4. Audit the license package before commercial deployment.
5. Benchmark against Qwen3.5-397B-A17B under identical serving conditions.

Until a corrected artifact is available and tested, keep the historical release claims separate from current deployability. This update did not download model weights or reproduce a benchmark.

Source List

Primary Rio sources

• Rio 3.5 Open 397B Hugging Face model card
• Rio README
• Rio raw config.json
• Rio safetensors index
• Rio Hugging Face API metadata
• Rio benchmark image in repo
• Rio discussion #2 on SwiReasoning
• IplanRIO official site

Base model and open-weight peers

• Qwen3.5-397B-A17B
• DeepSeek-V4-Pro
• Kimi-K2.6
• Kimi K2.6 technical blog
• MiniMax-M3
• GLM-5
• Z.ai GLM-5 blog
• Meta Llama 4 announcement

Frontier-lab context

• OpenAI GPT-5.5
• Anthropic Claude Opus 4.8
• Google DeepMind Gemini 3.1 Pro
• xAI Grok 4

Benchmark and reasoning sources

• Terminal-Bench
• Terminal-Bench 2.1
• SWE-Bench Verified dataset
• SWE-Bench Pro dataset
• DeepSWE
• MCP-Atlas leaderboard
• MCP-Atlas paper
• SwiReasoning paper
• SwiReasoning code

Internal Kingy AI links used

• Which AI Model Should You Use?
• Open-source AI models, local LLMs, hardware, and AI sovereignty
• The state of AI agents in 2026
• What is Model Context Protocol?
• Chain-of-thought explained
• DeepSeek V4 deep dive
• Kimi K2.6 analysis
• AI model picker