Qwen3.8's 95 Billion Active Parameters, IBM's Cheaper Agent Memory, and Why Chinese Labs Now Own Permissive Licensing

Alibaba just open-sourced the largest weight release the open ecosystem has seen: Qwen3.8-2.4T-A95B, 2.4 trillion parameters total. But the number that actually matters is 95 billion — that's how much of the model fires on any given token, because it's a fine-grained mixture-of-experts design. Instead of a few giant experts, Alibaba split capacity across a much larger population of smaller ones, and a learned router picks which slice answers each token. Serving cost tracks the 95B active parameters, not the 2.4T total, which is the only reason a model this size is deployable outside a hyperscaler's own data center. That distinction is the whole story here: a dense 2.4T model would be unusable for almost anyone, but a sparse one with 95B active parameters starts to look like something a well-funded startup could actually rent by the token.

The architecture is just as deliberate. Qwen3.8 alternates between full attention, where every token attends to every other token, and linear attention, where the growing key-value cache gets replaced by a bounded recurrent state. That hybrid is what lets the model hold a 1-million-token context window without memory and compute exploding as a conversation grows — a real constraint for agentic workloads that pile up system instructions, tool outputs, retrieved documents, and reasoning traces before the actual question ever gets asked. Output is capped at 128,000 tokens, which is generous by most standards but a reminder that even a million-token context window is mostly built for reading, not writing. Alibaba also built in three reasoning depths — low, high, and xhigh — so a developer can dial the model down for high-volume document processing or up for a genuinely hard multi-step task.

NVIDIA published the first performance numbers, and they come with a caveat worth sitting with: this is NVIDIA benchmarking its own hardware, not an independent third party. On a GB300 NVL72 rack — 72 Blackwell Ultra GPUs on a 130 TB/s NVLink domain — the model hit over 4,000 tokens per second per GPU and over 350 tokens per second per user, in FP8, with no additional tuning, on day zero. NVIDIA says that's a floor: NVFP4 precision and further optimization are expected to push throughput higher. Read the number for what it is — a vendor showing off its own silicon on its own rack — but even a skeptical read of that benchmark points at real headroom still on the table.

What makes this release notable isn't just the size, it's the access. Weights are live on Hugging Face and ModelScope today, with day-zero support across vLLM, SGLang, and NVIDIA Dynamo, plus a model-free NIM container and a NeMo AutoModel path for fine-tuning without converting checkpoints. Five hosted API providers — DeepInfra, DigitalOcean, Fireworks AI, Modal, and OpenRouter — are already serving it, so teams without a 72-GPU rack can rent inference by the token instead. That's the real shift worth noticing: a frontier-scale model shipping with a full serving stack on day zero, not months later once the community reverse-engineers how to run it.

Most agent failures on multi-step tasks aren't knowledge gaps. Ask an agent to split a bill, find a contact, or paginate an API correctly, and when it fails, it isn't because it doesn't know the tools exist — it's because it hasn't internalized how to use them reliably. That's the premise IBM Research's Ashwath Vaithinathan Aravindan opens with in a new Hugging Face post, and it's the shared starting point for two competing memory systems: ACE (Agentic Context Engineering) and IBM Research's own open-source ALTK-Evolve. Both let an agent learn from its past trajectories, and both agree lessons should be counted, not compressed into a handful of generic rules. Where they split is what to do with those lessons once you have them.

ACE injects its entire, ever-growing playbook into the model's context on every single step, regardless of task or model. ALTK-Evolve treats delivery as a dial instead of a constant: a small core of high-support guidelines, extended with a few retrieved for the task at hand, or the full set when a model has room to actually use it. That one design choice is what shows up in the bill.

IBM Research ran both systems in-house on AppWorld's test_normal split — 168 tasks where a ReAct agent splits bills, finds songs, and reconciles orders across nine simulated apps — using identical base models and harness for each: DeepSeek-V3.2 as the strong model, gpt-oss-120b as the weak one. On the strong model, ALTK-Evolve beat ACE on accuracy while spending only about 40% of its inference tokens. On the weak model, the two landed close to tied — 56.0 to ACE's 54.8, a gap IBM Research calls noise, since a repeat run came in at 54.8 — but ALTK-Evolve got there on roughly 14% of ACE's tokens, about one-seventh.

What's more interesting than the top-line numbers is where the accuracy actually comes from. Broken down by difficulty, this isn't simply retrieval beating playbook. On gpt-oss-120b, ACE's full playbook wins the easy and medium tasks, where generic instruction-following does most of the work anyway. But on hard tasks — the ones where the agent has to pick out the one relevant lesson instead of skimming past dozens — curated retrieval pulls ahead, and hard tasks are what decide the aggregate score. On the stronger DeepSeek-V3.2, the pattern flips: extra capacity lets the model absorb ACE's full playbook well enough to edge ALTK-Evolve on medium tasks, but ALTK-Evolve still leads easy, hard, and overall.

The lesson IBM Research draws is that context size isn't free just because the tokens are cheap. A weaker model can drown in a comprehensive playbook the same way a junior engineer drowns in an over-documented runbook, while a stronger model can afford to read the whole thing and come out ahead. ALTK-Evolve's bet is that how much memory to inject should be a per-model, per-task decision — not a fixed constant baked into the prompt template.

Hugging Face's Summer 2026 report tracks 2.96 million public model repositories on the Hub as of August, up from 2.43 million in January. Buried in that growth is a licensing pattern that's easy to miss and hard to ignore once you see it. Of the 178 Chinese model releases above 20 billion parameters this year, 59% carry an Apache 2.0 license and 22% carry MIT -- not one carries a non-commercial restriction. On the American side of the same size class, only 29% use Apache or MIT, 41% sit under custom terms, and 30% declare no license at all.

That's backwards from what you'd expect: the biggest, most expensive models are supposed to carry the tightest licensing, since they're the ones that cost the most to train and could, in theory, generate the most licensing revenue. Instead, DeepSeek and Z.ai ship models between 700 billion and 1.65 trillion parameters under plain MIT -- more permissive than what many US labs put on models a tenth that size. Chinese labs are also skipping the usual ship-small-then-scale-up pattern and going straight to frontier scale: the largest Chinese open model in a given month hit as high as 2.78 trillion parameters this year, while the American ceiling stayed under 130 billion in five of seven months.

None of this makes sense as a licensing business, and that's the part worth sitting with. If you're giving weights away on the loosest terms available, the money has to come from somewhere else -- API access, cloud contracts, hardware sales, ecosystem gravity. That last piece matters most, and it's the one easiest to underrate: a permissive frontier model doesn't just get downloaded, it gets built on, fine-tuned, quantized, and redistributed by a community that has no reason to leave once it's settled in. Qwen is the clearest case -- its derivatives on the Hub now number over 150,000, roughly 2.6 times Meta's entire footprint. That's not a model release anymore; it's a default choice developers stop reconsidering.

That activity isn't evenly spread, either. Just 1.5% of repositories on the Hub account for 99.2% of all downloads, meaning most of the 2.96 million repos are effectively noise -- uploaded once, touched rarely, mattering to almost no one's pipeline. The permissive-license trend matters because it's concentrated exactly where the traffic is: the handful of frontier and near-frontier releases that actually reach production. License terms on a model nobody downloads don't move any market. License terms on a model sitting at the top of that curve do, and right now the labs writing the loosest terms are the ones with the biggest models on that curve.

PrivAiTe sits between your coding agent and the model provider, intercepting Anthropic Messages API, OpenAI Responses API, and LiteLLM traffic and stripping PII and credentials out of tool-call parameters before they leave your machine, according to the project's GitHub page. It's built for the exact failure mode that makes agentic coding risky on private repos: an agent reads a file, runs a command, and pastes whatever it finds -- API keys included -- straight into a request body. The project's own benchmark reports catching 22 to 24 out of 24 planted credentials, with redaction adding roughly 1 to 3 seconds of latency per request.

According to Pillar Security, the campaign it's calling Deadbugz is still running: it has already tracked 23 malicious pull requests submitted under the identifier zellkernel, some going up and merging within 74 minutes. The trick is patience by design. A poisoned MCP tool behaves exactly like its honest counterpart through three ordinary calls -- fetching a file, running a lint, whatever the workflow needs -- before it quietly rewrites its own metadata and starts reading SSH keys and cloud credentials off the host. Any review or scan that only checks the tool's first few calls would see nothing wrong.

Anthropic set an unreleased model loose on the Riemann hypothesis, one of mathematics' unsolved Millennium Prize problems, by splitting the work across 60 specialized subagents instead of asking one model to reason straight through. Some agents explored possible approaches, generating 650 distinct ideas, according to Anthropic; others validated candidate steps; a separate layer wrote up results. The whole run consumed 31 million tokens over 36 hours, the company said. Rather than trust the model's own sense of whether a proof step held up, Anthropic piped generated logic through Lean, an open-source formal proof assistant that checks mathematical claims the way a compiler checks code -- accept or reject, no partial credit.

OpenAI says its new Ultrafast mode for GPT-5.6 Sol runs on Cerebras wafer-scale hardware and returns responses up to 14 times faster than the standard API, according to the company's own announcement. The mode is rolling out first to a limited set of API customers rather than the general public, and OpenAI hasn't published independent benchmarks alongside the claim. What's notable is the strategy: rather than optimizing GPT-5.6 Sol itself, OpenAI bolted on someone else's silicon to buy speed, a tacit admission that GPU-based inference has a latency ceiling that architecture tweaks alone won't crack for real-time use cases.