🎧 Jev: What’s Behind the Buzz?

Jev is getting attention with a simple promise: AI that makes a choice instead of writing an answer. But what does that actually mean?

In this episode, we unpack TypeSafe AI’s new model: what it is, how software can use it to sort requests or choose a next step, and why its claims of faster, cheaper decisions are attracting interest.

We also look at what Jev does not solve. A neatly formatted answer can still be wrong, and the company’s performance claims need independent testing. What is useful here, and what still needs proving?

Inspired by the work of Diogo Almeida and the TypeSafe AI team, this episode was created using Google's NotebookLM.

Read the original announcement here: https://typesafe.ai/blog/introducing-system-one-models-and-jev

🎧 Grounding Agent Memory: When AI Must Check What It Remembers

An AI assistant that remembers yesterday can repeat yesterday’s mistakes. This episode explores research from Microsoft on checking an agent’s memories against its working environment before saving them for future tasks.

A separate curator inspects databases or documents through read-only tools, then corrects, narrows or discards uncertain memories. In one database benchmark, success reached 73%, compared with 70% for memory alone and 39% without memory. The question is whether better verification justifies its extra background work: reported task-agent savings exclude curation costs.

Inspired by the work of Susheel Suresh, Hazel Mak, Sahil Bhatnagar, Chhaya Methani and Alejandro Gutierrez Munoz, this episode was created using Google's NotebookLM.

Read the original paper here: https://arxiv.org/abs/2609.11060v1

🎧 Recursive Self-Improvement: AI Must Learn to Improve Its Own Learning

An AI that fixes one answer has not necessarily learned anything for tomorrow. Recursive self-improvement asks for something harder: changes that persist across tasks and reshape how the system makes its next improvements.

We explore a new research roadmap that separates five levels of autonomy, from executing prescribed updates to revising the mechanisms of improvement itself. The distinction matters for anyone deciding how much control to give an agent over its tools, training, and evaluation.

The paper surveys emerging systems and preliminary industry evidence. It offers a framework for judging progress, not proof that fully autonomous recursive improvement has arrived.

Inspired by the work of Yi Duan and colleagues, this episode was created using Google's NotebookLM.

Read the original paper here: https://www.alphaxiv.org/abs/2609.11873

When an AI agent fails after dozens of steps, the final error rarely reveals where the problem began. AGENTSCOPE turns long execution traces into structured reasoning-action graphs, then checks them against ten neural invariants covering reasoning, control flow, and tool use.

On the new AgentErrata benchmark, it raised exact failure-step localization from 1.32% to 31.35% with GPT-5.1 and more than doubled failure-type accuracy over a direct LLM judge. Yet the best exact localization score remains only 34.98%, and AgentErrata relies on injected, manually verified failures rather than organic production incidents.

Inspired by the work of Jiayi Bi, Yanjie Gao, Yuanmin Xie, Liqun Li, Tianyin Xu, Fan Yang, and Mao Yang, this episode was created using Google's NotebookLM.

Read the original paper here: https://arxiv.org/abs/2609.02371

🎧 WikiSkill: Why Agent Experience Needs a Memory Layer

Google Research's WikiSkill separates raw execution traces, persistent knowledge, and executable skills. The authors report that this architecture improves skill evolution across five benchmarks and models, and that evolved skills can transfer between model families. Their ablation study attributes a 15-point average gain to giving the Skill Proposer access to the persistent wiki.

For builders, this suggests that an agent's learning infrastructure can matter alongside model size: preserve the evidence behind a skill update, not only the final instructions. The study directly injects skills into prompts, does not evaluate retrieval or triggering, lacks automated wiki pruning, and excludes very long-horizon tasks.

Inspired by the work of Liyan Tang, Cyrus Rashtchian, Chun-Sung Ferng, Andrew Tomkins, Da-Cheng Juan, and Tu Vu, this episode was created using Google's NotebookLM.

Read the original paper here: https://arxiv.org/abs/2608.27454

AI agents can regress even when their foundation model never changes. The culprit may be the harness around the model: prompts, memories, tools, skills, and routing rules that evolve after every task. This episode explores Harness Continual Learning, a framework that treats this external state as the real object of adaptation. It introduces harness-level forgetting, four jointly versioned components, and a guarded proposal, evaluation, and commit loop designed to preserve reliable behavior while adding new capabilities. The paper reports gains above 10% over several baselines, but also shows that more permissive updates do not always produce a stronger final agent.

Inspired by the work of Borui Kang, Jinrui Gu, Junhan Lv, Wenbin Li, Lei Wang, and Yang Gao, this episode was created using Google's NotebookLM.

Read the original paper here: https://arxiv.org/pdf/2608.19013

The next frontier in AI is not better prompts. It is systems that trigger, act, observe, judge, and stop on their own. This episode explores loop engineering: the shift from manual chat with an AI to autonomous workflows that can test software, review documentation, simulate users, inspect screenshots, fix errors, and open pull requests while humans sleep.

But autonomy has a cost. Without hard stop conditions, independent verification, maker-checker separation, and spending limits, loops can burn tokens, produce quiet technical debt, or drift into days of useless activity.

Inspired by recent analyses from Matthew Berman, Nate Hunter, and the Prompt Engineering channel, this episode was created using Google's NotebookLM. Source note: this episode is based on multiple technical videos and developer discussions.

What if today’s “AI agents” are mostly automation pipelines wearing a more ambitious label?

This episode explores Critique of Agent Model, a paper that draws a sharp line between agentic systems, which look autonomous because engineers scaffold workflows around them, and agentive systems, where goals, identity, decisions, self-regulation, and learning are internal to the system itself.

The authors propose a Goal-Identity-Configurator (GIC) architecture as a path toward genuine machine agency, while keeping the central safety question unavoidable: greater autonomy also makes oversight significantly more difficult.

Inspired by the work of Eric Xing, Mingkai Deng, and Jinyu Hou, this episode was created using Google’s NotebookLM.

Read the original paper here: https://arxiv.org/abs/2606.23991