Nemotron 3.5, AI research integrity, and smarter agent skills

Today’s most important AI news

Halloween brought a mix of launches and uncomfortable revelations. NVIDIA quietly released two new open-weight models built on a hybrid architecture that challenges the standard transformer playbook. Meanwhile, a forensic re-analysis of AI-written research papers found a problem more subtle — and more worrying — than simple hallucination. Rounding out the day, two independent research teams tackled the same practical headache: how agents can accumulate skills without constantly re-running expensive inference.

Nemotron 3.5 Super and Lightning: NVIDIA’s hybrid MoE models aim at production agents

NVIDIA released Nemotron 3.5 Super and Nemotron 3.5 Lightning, two open-weight models that combine Mixture-of-Experts routing with a hybrid Mamba-Transformer architecture. Super is a 120B-parameter model that activates only 12B parameters per forward pass and supports multimodal input; Lightning is a leaner 30B-parameter model with 3B active parameters focused entirely on text. Both were trained with large-scale knowledge distillation and long-context data, and both are explicitly designed for agentic workloads — meaning sustained multi-step tasks rather than one-shot queries.

The architectural choice is the real story here. Pure transformer models scale quadratically with context length, which makes long agentic sessions expensive. Mamba’s selective state-space layers handle long sequences more efficiently, and mixing them with transformer attention layers is a pragmatic attempt to keep reasoning quality high while cutting memory and compute costs. The fact that Super activates only 10 percent of its parameters per token means you get frontier-class capability at something closer to a 12B serving cost.

For engineering and product teams evaluating their model stack, Nemotron 3.5 Super is the first open-weight multimodal model in this parameter class that is explicitly tuned for agent loops. If your workloads involve long contexts, tool use, or multi-step reasoning — and you want to run them on your own infrastructure rather than through an API — this release is worth a serious benchmark run before your next infrastructure review.

AI-written research papers have a numbers problem that goes beyond hallucination

A preprint from researchers who re-examined all 540 publicly released AI-agent-written papers found a failure mode distinct from outright fabrication: misattributed numbers. The models were not inventing statistics wholesale; they were pulling real figures from real sources and placing them in the wrong context, attributing them to the wrong study, or applying them to a different claim than the one the original paper supported. A single LLM judge checking for internal consistency would miss most of these errors entirely.

This matters because the standard integrity checks used on AI-generated text are designed to catch two things: numbers that appear nowhere in the agent’s outputs, and internal contradictions within the same document. Misattribution defeats both tests — the number is real, it appears in a source the agent accessed, and the document is internally consistent. The problem only surfaces when you trace each claim back to its original context, which is exactly what the authors did manually across the full 540-paper corpus.

For anyone deploying AI agents in research, due-diligence, or content workflows, the takeaway is operational. Internal consistency checks and hallucination detectors are not sufficient for numerical claims. You need citation-level verification: did the number in this sentence actually support this claim in the source document? That is a harder, slower check, but the alternative is publishing analysis built on correctly-sourced but incorrectly-applied evidence — which in regulated industries or high-stakes decisions is just as dangerous as a fabricated number.

Two approaches to making agent skills stick without endless re-inference

Two papers published today address the same structural inefficiency in agentic AI from different angles. SkillMem proposes storing each reusable skill as a small external latent memory — a compact continuous representation — rather than as text that must be re-parsed or as additional model parameters that bloat the system per skill. The second paper, “Compile Away Uncertainty,” argues that text-based skill documents are inherently unreliable because every execution requires the LLM to re-interpret the procedure, introducing variability each time. Their solution is to compile verified skills into executable programs, replacing probabilistic text interpretation with deterministic code execution.

The underlying tension both papers are responding to is real and growing. As agent systems accumulate experience, storing learned procedures as plain text creates a compounding inference tax: the agent must re-read, re-interpret, and re-generate each skill on every use. That is fine for a handful of skills, but it becomes a bottleneck at scale. SkillMem tries to solve the storage and retrieval side; “Compile Away Uncertainty” tries to solve the execution reliability side. They are not mutually exclusive — a production system might benefit from both.

Practically, neither approach is ready to drop into most agent frameworks today, but they signal where the field is heading: away from pure prompt-based skill management and toward hybrid memory systems that combine learned representations with deterministic execution paths. Teams building proprietary agent platforms should be watching this space, because the teams that solve reliable, scalable skill reuse will have a meaningful latency and cost advantage within the next product cycle.

In a nutshell

Step back from the individual stories and a single theme emerges: the gap between what AI systems appear to do and what they actually do under scrutiny is getting harder to ignore. Nemotron 3.5 is a genuine capability leap, but its value is measured at deployment time, not benchmark time. The misattributed-numbers study is a direct challenge to the assumption that impressive-looking agent output is trustworthy output. And the skill-memory papers both exist because “the agent learned it once” does not yet mean “the agent will do it reliably the second time.” The industry is in a phase where the surface area of AI deployment is expanding much faster than the tooling for verifying what those deployments actually produce. The researchers publishing integrity benchmarks and auditable belief systems are not being pessimistic — they are building the instrumentation layer that serious production AI will eventually require.

---

Sources used: Nemotron 3.5 Super and Lightning (https://arxiv.org/abs/2610.38095), Beyond fabrication: Misattributed numbers in papers written by AI research agents (https://arxiv.org/abs/2610.38691), SkillMem: Compact External Skill Memory for Latent Multi-Agent Reasoning (https://arxiv.org/abs/2610.37935), Compile Away Uncertainty: Self-Evolving Agent Skills via Programmatic Compilation (https://arxiv.org/abs/2610.39508)