AI Odyssey

Anlie Arnaudy, Daniel Herbera and Guillaume Fournier

AI Odyssey is your journey through the vast and evolving world of artificial intelligence. Powered by AI, this podcast breaks down both the foundational concepts and the cutting-edge developments in the field. Whether you're just starting to explore the role of AI in our world or you're a seasoned expert looking for deeper insights, AI Odyssey offers something for everyone. From AI ethics to machine learning intricacies, each episode is crafted to inspire curiosity and spark discussion on how artificial intelligence is shaping our future.

Play

Open in

20 episodes
weekly
Avg 21 min
English

Episodes 20

Newest Oldest Longest

All20 Unplayed20 In progress0 Played0

Sunday · 19 min
AGENTSCOPE: Why Bigger Models Do Not Fix Agent Debugging
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
August 29 · 25 min
WikiSkill: The Memory Layer Agent Skills Were Missing
🎧 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
August 22 · 22 min
Harness Continual Learning: Your Agent Can Forget Without Changing Its Model
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
July 6 · 23 min
Prompting Is Dead. Loops Are the New Interface.
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.
June 27 · 22 min
AI Agents Are Not Agents Yet
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
June 15 · 21 min
The End of Shared Memory for AI Agents?
What if the best way for AI agents to learn together is to stop forcing them to share the same memory? This paper introduces DecentMem, a framework where each agent keeps its own adaptive memory instead of relying on one central repository. The result is striking: better accuracy, lower token use, and less risk of every agent collapsing into the same behaviour. For enterprises building agent teams, the message is uncomfortable: coordination is not always intelligence. Sometimes, shared memory is the bottleneck. Inspired by the work of Guangya Hao, Yunbo Long, and Zhuokai Zhao, this episode was created using Google's NotebookLM. Read the original paper here: https://arxiv.org/abs/2605.22721
June 7 · 19 min
Your Best Colleague Is Now a Skill
What if an AI agent could preserve a colleague’s judgment without pretending to become that person? COLLEAGUE.SKILL turns chats, documents, emails, screenshots, and other traces into inspectable agent skills: portable folders of instructions, examples, metadata, and correction history. The key idea is expert knowledge distillation : the extraction of useful human expertise into a bounded technical artifact. For enterprises, this points to a new operating model. Scarce expertise can become reusable, auditable, and updateable, but only if provenance, consent, and limits remain visible. Inspired by the work of Tianyi Zhou, Dongrui Liu, Leitao Yuan, Jing Shao, and Xia Hu, this episode was created using Google's NotebookLM. Read the original paper : https://arxiv.org/abs/2605.31264
May 31 · 22 min
AI Agents Just Learned to Train Their Own Skills
What if the next leap in AI agents is not a bigger model, but a skill document that learns from failure? SkillOpt treats agent skills as trainable external memory: a separate optimizer edits a compact procedure, then keeps only changes that improve held-out validation, meaning tests not used for the edit. Across 52 model, benchmark, and harness settings, the method is best or tied every time, with gains above 20 points on GPT-5.5 in several loops. For enterprises, this points to a new layer of governance: skills that improve, transfer, and remain auditable. Inspired by the work of Yifan Yang, Ziyang Gong, Weiquan Huang, Qihao Yang, Ziwei Zhou, Zisu Huang, Yan Li, Xuemei Gao, Qi Dai, Bei Liu, Kai Qiu, Yuqing Yang, Dongdong Chen, Xue Yang, Chong Luo, this episode was created using Google's NotebookLM. Read the original paper here: https://arxiv.org/abs/2605.23904
May 25 · 23 min
AI Agents Fail the Spreadsheet Test
What happens when AI agents are asked to build the spreadsheets finance teams actually use? WorkstreamBench, a benchmark for end-to-end financial spreadsheet work, exposes the gap between impressive demos and professional deliverables. It tests complete multi-sheet workbooks, not single formulas or table questions. The benchmark scores accuracy, formula quality, and formatting, because in finance a model must be auditable, readable, and easy to modify. Claude Web leads with 69.1 out of 100, but even the best systems degrade as tasks become more complex. Enterprise AI still has a spreadsheet reliability problem. Inspired by the work of Thomson Yen, Julian Poeltl, Harshith Srinivas Gear, Yilin Meng, Joshua Fan, Adam Shen, Yili Liu, Ali Bauyrzhan, Siri Du, Haoyang Liu, Daniel Guetta, and Hongseok Namkoong, this episode was created using Google's NotebookLM. Read the original paper here: https://arxiv.org/pdf/2605.22664
May 16 · 15 min
Hermes Agent and the Rise of Agentic Operating Systems
Every forty years, the way we touch a computer changes shape. The command line gave way to the mouse. The mouse gave way to the touchscreen. And now, quietly, the screen itself is starting to disappear. In this episode, we follow Hermes, an open-source agentic operating system that hit number one on OpenRouter in ninety days, processing 224 billion tokens a day. Persistent memory, self-written skills, local-first execution: Hermes is not an app you launch, it is a digital coworker that launches things for you. And while the text interface collapses into orchestration, the voice interface is collapsing into presence: Mira Murati's Thinking Machines Lab just unveiled "interaction models" that listen, watch, and speak at the same time, in 200-millisecond micro-turns. Two paradigm shifts, one direction. The OS becomes the agent. The agent becomes the conversation. Inspired by recent research on Agentic Operating Systems, this episode was created using Google's NotebookLM.
May 14 · 18 min
The Agent Question Nobody Asked: When Should AI Interrupt You?
Most people assume an AI agent should ask for clarification as early as possible. This paper shows that the truth is more subtle. For long-horizon agents — AI systems that execute many steps over time — the value of a clarification depends on what is missing : goal, input, constraint, or context. Some answers lose value almost immediately. Others remain useful much later. For enterprises, this is not a UX detail. It is a governance problem : when should an agent stop, ask, and avoid compounding a bad assumption? Inspired by the work of Anmol Gulati, Hariom Gupta, Elias Lumer, Sahil Sen, and Vamse Kumar Subbiah, this episode was created using Google's NotebookLM. Read the original paper here : https://arxiv.org/abs/2605.07937v1
May 10 · 25 min
AI Agents Have a Coordination Problem
What if multi-agent AI systems fail less because the models are weak, and more because the agents are badly coordinated? This paper treats coordination as an architectural layer : who talks to whom, who decides, how outputs are merged, and how failures are handled. The authors test five coordination patterns on prediction markets and find a sharp result for builders : more agents and more debate do not automatically create better systems. In this experiment, simple ensembles and sequential pipelines beat popular orchestration patterns on the cost-quality frontier. Inspired by the work of Maksym Nechepurenko and Pavel Shuvalov, this episode was created using Google’s NotebookLM. Read the original paper here : https://arxiv.org/pdf/2605.03310
May 3 · 17 min
AI Agents Are Becoming Companies
What if the next leap in AI agents is not a smarter worker, but a better organisation? This paper introduces OneManCompany, a framework that turns scattered agents, tools, skills, and runtime configurations into managed “Talents” that can be hired, reviewed, replaced, and improved over time. Its Explore-Execute-Review loop decomposes work, assigns accountability, checks outputs, and learns from failures. The result is striking: 84.67% success on PRDBench, beating reported baselines by 15.48 percentage points. But the catch is equally important: this organisational intelligence costs more and is still mostly validated on software tasks. Inspired by the work of Zhengxu Yu, Yu Fu, Zhiyuan He, Yuxuan Huang, Lee Ka Yiu, Meng Fang, Weilin Luo, and Jun Wang, this episode was created using Google’s NotebookLM. Read the original paper here: https://arxiv.org/abs/2604.22446v1
April 27 · 18 min
AI Agents Just Learned to Remember
What if the real bottleneck for AI agents is not reasoning,but memory? StructMem argues that long-term agents should not storeconversations as isolated facts or expensive knowledge graphs. Instead, they should remember temporally grounded events: what happened, who was involved, and how one event connects to another. On the LoCoMo benchmark, thisstructure-enriched memory reaches the best overall score while cutting construction costs dramatically compared with graph-heavy approaches. For anyone building autonomous agents, the message is clear:memory is becoming an architecture problem, not just a retrieval problem. Inspired by the work of Buqiang Xu, Yijun Chen, Jizhan Fang,Ruobin Zhong, Yunzhi Yao, Yuqi Zhu, Lun Du, and Shumin Deng, this episode was created using Google's NotebookLM. Read the original paper here: https://arxiv.org/pdf/2604.21748v1
April 18 · 20 min
The Protocol That Lets Agents Rewrite Themselves
What if the missing layer in agent design isn't communication, but version control? In this episode, we unpack Autogenesis, a two-layer protocol that treats prompts, tools, and memory as first-class resources with explicit lifecycle, versioning, and rollback. The core insight is striking: connectivity standards like MCP and A2A tell agents how to reach tools, but stay silent on what happens when agents start rewriting those tools on their own. Autogenesis fills that gap, and the numbers speak loudly, including a 33% jump on the hardest GAIA benchmark tasks. Inspired by the work of Wentao Zhang, this episode was created using Google's NotebookLM. Read the original paper here: https://arxiv.org/abs/2604.15034
April 12 · 25 min
When Agents Learn to Forget: The Memory Revolution in AI Research
What if the biggest bottleneck in AI agents wasn't reasoning power, but memory management? In this episode, we explore a fascinating new framework called MIA, the Memory Intelligence Agent, which reimagines how AI research agents store, compress, and reuse their past experiences. Instead of hoarding every search trace into an ever-growing context window, MIA separates memory into a Manager, a Planner, and an Executor, each with a distinct role. The result: a 7-billion parameter model that outperforms GPT-4o on complex research tasks, and even boosts GPT-5.4 performance by up to 9%. We unpack why "keeping everything" is a trap, and how forgetting strategically might be the real key to smarter AI. Inspired by the work of Jingyang Qiao, Weicheng Meng, Yu Cheng, and colleagues at East China Normal University, this episode was created using Google's NotebookLM. Read the original paper here: https://arxiv.org/pdf/2604.04503
April 6 · 23 min
The Web is a Minefield: How AI Agents Get Trapped
What if the biggest threat to AI agents isn't a flaw in the model, but the internet itself? A new paper from Google DeepMind introduces the first systematic framework for "AI Agent Traps": adversarial content hidden in websites, documents, and digital resources, engineered to manipulate autonomous agents. From invisible HTML instructions that hijack summaries, to poisoned memory stores that corrupt decisions across sessions, to systemic traps that could trigger flash crashes across agent economies. The researchers identify six categories of attack targeting every layer of an agent's architecture: perception, reasoning, memory, action, multi-agent dynamics, and the human overseer. As enterprises deploy agents at scale, this paper is a wake-up call: the web was built for human eyes, and rebuilding it for machine readers demands a fundamentally new security playbook. Inspired by the work of Matija Franklin, Nenad Tomašev, Julian Jacobs, Joel Z. Leibo, and Simon Osindero, this episode was created using Google's NotebookLM. Read the original paper here: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6372438
March 29 · 24 min
🎧 AI That Rewrites Its Own Brain: Meet the HyperAgent
What happens when you give an AI system the ability to modify not just its answers, but the very process it uses to improve itself? In this episode, we explore HyperAgents, a new framework from Meta and UBC that enables AI systems to recursively improve their own learning mechanisms. Unlike previous approaches where the improvement strategy was fixed by human engineers, HyperAgents can rewrite their own self-improvement code, creating a loop where getting better at a task also means getting better at getting better. The results are striking: improvements discovered in one domain, like reviewing research papers, transfer to completely unrelated tasks like grading Olympic math solutions. Inspired by the work of Jenny Zhang, Bingchen Zhao, Wannan Yang, Jakob Foerster, Jeff Clune, Minqi Jiang, Sam Devlin, and Tatiana Shavrina, this episode was created using Google's NotebookLM. Read the original paper here: https://arxiv.org/abs/2603.19461
March 22 · 21 min
When Agents Remember Their Mistakes: The End of AI Amnesia
What if an AI agent could learn from every single failure, every clumsy workaround, every brilliant recovery, and feed that experience back into its own future performance? Today’s LLM-powered agents suffer from a fundamental flaw: amnesia. They repeat the same mistakes, miss the same shortcuts, and rediscover the same solutions over and over. A new framework from IBM Research changes that by mining agent execution trajectories for three types of actionable knowledge: strategy tips from clean successes, recovery tips from failure-and-fix sequences, and optimization tips from tasks completed inefficiently. On the AppWorld benchmark, agents equipped with this learned memory improved scenario goal completion by up to 14.3 percentage points on unseen tasks, and by a staggering 28.5 points on complex multi-step challenges. That is a 149% relative increase, with zero model changes. Inspired by the work of Gaodan Fang, Vatche Isahagian, K. R. Jayaram, Ritesh Kumar, Vinod Muthusamy, Punleuk Oum, and Gegi Thomas, this episode was created using Google’s NotebookLM. Read the original paper here: https://arxiv.org/abs/2603.10600
March 14 · 13 min
Agents That Teach Themselves
What if AI agents could diagnose their own mistakes and build the exact skills they need to fix them, with no human intervention? In this episode, we explore EvoSkill, a self-evolving framework where coding agents automatically discover and refine reusable skills through iterative failure analysis. Instead of optimizing prompts or fine-tuning models, EvoSkill lets agents build structured skill libraries that accumulate over time, improving performance by up to 12% on challenging benchmarks. Even more striking: skills learned on one task transfer to completely different tasks without modification. Inspired by the work of Salaheddin Alzubi, Noah Provenzano, Jaydon Bingham, Weiyuan Chen, and Tu Vu, this episode was created using Google’s NotebookLM. Read the original paper here: https://arxiv.org/pdf/2603.02766

Showing 1–20 of 20 episodes