The AI Abstract — Morning Edition

The field's standard way of measuring AI safety has a hole in it large enough to drive a moderation failure through. Researchers testing five major models on Urdu hate speech found that the same piece of content gets classified differently depending on whether the model sees it in Urdu script or reads an English translation first. That gap runs between 15.9 and 31.6 percentage points across models. Up to 9.9% of harmful content gets missed entirely when it arrives in Urdu. The paper, 🔬"Ghaib in Translation", audited nine years of safety benchmark proceedings and found Urdu systematically absent, despite it being the tenth most-spoken language on Earth. The mechanism here matters: models trained and evaluated almost entirely on English-script data develop safety behaviors that are bound to the script and syntax of that training, not to the underlying concepts. Run the same hateful phrase through translation before evaluation and the model catches it. Read it natively and the pattern doesn't trigger. That's not a tuning problem. It's a structural gap between what these systems were built to recognize and where harmful content actually circulates. Smaller open-weight models show the worst instability, which is significant because those are the models most likely to be deployed by organizations operating in South Asian contexts without the resources to run frontier-scale inference. Every content moderation system certified against English-dominant benchmarks is effectively uncertified for Urdu.

The mechanism behind how agents remember things just got a significant redesign. 🔬Recuris introduces a memory architecture that splits two things current agent systems keep tangled together: the full history of what a task involved, and the immediate working context the agent needs right now. Most agents today carry everything forward in a single growing context window, like trying to cook a meal while reading every recipe you've ever used simultaneously. Recuris keeps the historical record separate and queries it selectively when a local failure occurs, letting the agent refine which skills it calls without the entire task history creating noise. Tested across four benchmarks and ten models including GPT-5.6 and Claude Opus, the architecture produced 15 to 32 percentage point improvements on long-horizon tasks and cut common failure modes by 80%. The "recursive self-improvement" framing in the paper deserves attention: when an agent can localize its own failures and update its skill selection strategy within a bounded loop, that's a qualitatively different capability than an agent that simply tries again. This is a preprint and the benchmarks are self-reported, so independent replication matters, but the empirical spread across that many models and tasks is hard to dismiss.

A real-world deployment study of 1,872 conversation sessions found that the metric the entire field uses to evaluate AI memory is measuring the wrong thing. 🔬MemUse tested seven memory conditions across 40 users over four months and found that Direct QA accuracy, whether a model can retrieve a stored fact when asked point-blank, showed almost no relationship to whether users actually found the memory useful. What predicted satisfaction was something the researchers call Natural Integration: whether the model recognizes unprompted that a stored fact is relevant and weaves it in without being asked. A system that scores 70% on Direct QA but never volunteers context gets rated worse than one that scores lower on recall but uses what it knows at the right moment. The benchmark corpus is released publicly. Anyone building a conversational assistant and evaluating it on retrieval accuracy alone is measuring the wrong variable.

AI models can read a financial risk disclosure and then ignore it. 🔬This paper tested LLMs on documents up to 128,000 tokens long, confirmed they could accurately locate specific risk language within those documents, and then showed their investment judgments didn't change as a result. The retrieved information existed in the model's context but didn't propagate into the decision. The researchers call this the "retrieval-integration gap," and the practical consequence is direct: if you're evaluating an AI financial research tool based on whether it can find the right passage, you're not testing whether it uses that passage. Workflow architecture turns out to partially determine whether integration happens at all. Structured restatement pipelines outperform summarization pipelines on this measure. Scaling model size helps but doesn't close the gap.

IBM released 🔬Granite 4.2 under Apache 2.0 in three sizes (3B, 8B, 30B), trained on 15 trillion tokens with multi-stage agentic reinforcement learning that includes code editing, terminal control, and web browsing in sandboxed environments. The 30B model scores 57.0% on SWE-Bench Verified, which puts it in competitive territory for open models on real software engineering tasks. The practical value here is the license: Apache 2.0 means organizations can deploy and modify without royalty or usage restrictions, which matters for enterprises that can't commit to closed-API dependencies in regulated environments.

Two papers clustered today on reinforcement learning for agent safety. 🔬RePolicy trains agents to decide when to invoke safety policies based on context, rather than applying static rules at all times. The adjacent problem: current safety prompts either fire on everything (creating friction) or miss edge cases (creating risk). RePolicy learns which situations actually require policy invocation. 🔬FARCA attacks hallucination during RL training by assigning supervision at the token level rather than the response level, then weighting those signals by reliability. The idea is that if a model produces a hallucinated claim, the current standard approach penalizes the whole response. FARCA traces which tokens caused the error and filters out supervision signals it can't trust. Both papers represent early movement on reinforcement learning as a mechanism for safety behavior, a signal first logged in this brief three months ago that now has enough volume to track.

🔬AgentSpec addresses a different infrastructure bottleneck: batch inference speed for agent workloads. Speculative decoding, where a smaller draft model generates candidate tokens that a larger model then accepts or rejects, breaks down under agent workloads because agents produce structured outputs with interdependencies that cause high rejection rates. AgentSpec's contribution is isolating those structured elements during drafting to reduce wasted computation. Lower latency per agent call compounds significantly when you're running hundreds of agents in parallel.

A new survey across 46 papers maps where NLP has actually been deployed in emergency department workflows, from triage scoring to discharge documentation. 🔬The survey is useful primarily as a gap map: it identifies where task-specific models are giving way to LLMs, where clinical evaluation standards are still inconsistent, and where generalization fails under the time pressure and incomplete-information conditions that define ER practice.

One interpretability result worth noting: 🔬GI-SAE probed whether multilingual models share the same internal reasoning features across languages or run separate computations per language. The answer is that there is no universal pattern. Feature sharing across languages varies by model architecture and training setup, with no consistent principle that holds across the five models tested. That's a significant finding for anyone reasoning about whether a model "understands" math the same way in French as it does in English. It doesn't, necessarily. And whether it does depends on which model you're using.

---

🔬 "Ghaib in Translation": Read for the audit of nine years of safety proceedings and the mechanism explaining why script-bound safety training fails at language boundaries.

🔬 Recuris: Read for the architecture diagram separating experiential from working memory and the benchmark breakdown across model families.

🔬 MemUse: Read for the deployment methodology and the definition of Natural Integration as a metric you can apply to your own system.

🔬 Reading Is Not Using: Read for the workflow architecture comparison showing which pipeline designs close the retrieval-integration gap and by how much.

📰 IBM Granite 4.2: Read for the SWE-Bench and Terminal-Bench scores and the training pipeline details before evaluating it against your deployment constraints.