Skip to content

⚡️ Exo: Harnesses should see their own code and logs — Alex Krentsel, UC Berekeley / Google Research

Latent Space: The AI Engineer Podcast

47m
Transcript

Original podcast

Where to listen

Summary

Written by a model from the transcript; not yet reviewed.

This episode covers the architecture and philosophy of Exo, an open-source framework for recursively self-improving agents built by Alex Krentsel alongside Martin Casado and Ankur Goyal. The guest breaks down how Exo departs from existing tools like OpenClaw by separating the agent into three isolated layers: a stateful Exo harness that stores conversation history and secrets, a stateless policy executor, and a sandbox where actions execute. By giving the executor access to its own source code, the agent can inspect, modify, and rebuild itself at runtime while relying on the harness to automatically roll back any broken states. The discussion highlights real-world applications, such as an experiment where Exo re-architected its own Discord adapter to achieve a ninety-six percent reduction in token costs.

  • Isolate agent state, policy execution, and sandboxes so the system can safely modify its own code without leaking secrets or losing history. 16:18
  • Store API keys and sensitive credentials in a secret store within the harness rather than exposing them directly to the LLM inside the sandbox. 27:20
  • Annotate conversation logs with execution costs to allow policy executors to reason over token spending and optimize their own resource usage. 39:21
  • Enforce crucial system properties like history retention through architectural design rather than relying on in-context prompts that models can bypass. 14:37

Chapters

  1. 0:03
    Podcast Intro and Host Greeting

    Hosts welcome Alex Krentsel and set the stage for the episode.

  2. 1:13
    Alex Krentsel’s Background and Early Work

    Alex explains his collaboration with Martin Casado and Ankur Goyal and his system-focused research at Berkeley.

  3. 1:56
    Introducing EXO: Recursive Self-Improving Agent

    Alex outlines EXO’s core idea of a fully recursive agent that edits itself at runtime.

  4. 16:31
    Layered Architecture: Executor, Harness, Sandbox

    Detailed explanation of EXO’s three-layer design and how each layer contributes to safety and self‑improvement.

  5. 20:03
    Self‑Modification Workflow and Rollback Mechanism

    How EXO mounts its own executor code, rebuilds mid‑step, and rolls back if a change breaks the agent.

  6. 23:02
    Teleportation and Scalability Across Users

    Discussion of moving sandboxes between local and cloud environments to scale to many users.

  7. 27:20
    Security, Secrets, and Monitoring Practices

    Exploration of secret stores, access logs, and monitoring for agent safety and compliance.

  8. 31:00
    Real‑Time Interaction and Interruptible Work

    Challenges of interruptible tasks in agents and potential OS‑style solutions for real‑time responsiveness.

  9. 40:41
    Evaluations, Reward Hacking, and Goal Alignment

    Strategies for ensuring agents improve without unintended side effects and maintain alignment with user goals.

  10. 44:47
    Podcast Introduction and Host Greeting

    The hosts welcome listeners and introduce the episode’s topic and guest.

  11. 45:49
    Self‑Constructing Systems and Flywheel Effect

    The guest explains how Exo’s iterative layer creates a flywheel that accelerates progress.

  12. 46:19
    Future Work and Community Involvement

    The host and guest discuss how listeners can contribute via GitHub, Discord, and Twitter.

Highlights

  • 1:55

    Introducing Recursive Self-Improvementinsight

    The guest introduces Exo, an agent capable of safely editing all aspects of its own code and behavior at runtime through a minimal harness architecture.

  • 11:15

    Playing Pokemon and Inspecting RAMstory

    While running an experiment playing Pokemon, Exo autonomously inspected the game's memory map and modified its integration to improve decision-making.

  • 16:31

    Three-Tier Architecture Splitstrategy

    The architecture separates the agent into a stateless executor containing policy, an Exo harness holding state and secrets, and an isolated sandbox environment.

  • 22:01

    Scaling via Teleportationinsight

    Separating compute from storage allows sandbox environments to be teleported or spun up remotely in the cloud when local machine resources run out.

  • 40:00

    Reducing Token Costs by Ninety-Six Percentdata

    By analyzing conversation logs annotated with costs, Exo autonomously re-architected its Discord adapter and reduced token usage costs by ninety-six percent.

  • 42:57

    Code as the Building Mediuminsight

    Recursive self-improvement is uniquely possible now because the medium being edited—code—is the exact same medium the LLM produces as output tokens.

Quotes

  • “In a nutshell, EXO is an agent that's fully recursive.”
    Unnamed speaker · 1:55
  • “We are training the model. First, it was large pre‑training runs.”
    Unnamed speaker · 2:44
  • “The only way, I think, out of that is to collapse that loop down and make it so that the system itself is responsible for improving itself, which I'm calling to collapse the loop.”
    Unnamed speaker · 3:58
  • “The executor contains all of the policy.”
    Unnamed speaker · 16:58
  • “The secret store is really great. We want it to live in the EXO Harness so that it's not exposed directly to the LLM.”
    Unnamed speaker · 27:20
  • “I asked it, hey, how much did the last message cost in the Discord adapter? And it was like, it was 16 cents. It's like, are you serious? 16 cents? That's actually crazy.”
    Unnamed speaker · 39:47
  • “I'm very purist about this. Maybe coming from academia, this is my fault.”
    Unnamed speaker · 44:50
  • “Because this takeoff moment will come from being iterating in the same layer that you are producing, I think.”
    Unnamed speaker · 45:42
  • “We're always looking for contributors and more discussion partners.”
    Unnamed speaker · 46:39
  • GitHub 29:06–30:17

About this episode

Watch the full show on YouTube: https://www.youtube.com/watch?v=5lFD-34dhqE

Transcript

0:00
47:11

9,466 words · 2 speakers

Topics

  • EXO
  • OpenClaw
  • Discord
  • Daytona
  • Claude Code
  • Harbor
  • Twitter
  • Lisp
  • UC Berkeley
  • Skylab

Page updated · transcript and summary are machine-generated