TechnicalDiscussion

How to Build Long-Horizon AI Agents — Mitch Troyanovsky, Basis

Mitch Troyanovsky from Basis discusses how to build long-horizon autonomous AI agents that can reliably perform complex tasks like end-to-end tax returns. He emphasizes the importance of process-based evaluation over outcome-based metrics, behavior specifications, and system design principles drawn from how humans organize work, rather than relying solely on larger models and reasoning improvements.

Summary

Mitch Troyanovsky, co-founder of Basis (a unicorn AI company), explains how autonomous agents can operate for hours or days to complete complex real-world work like tax returns. Unlike coding agents which benefit from verifiable runtime signals, non-coding domains like accounting face three major challenges: agents don't know what good looks like, outcomes aren't easily verifiable at runtime, and quality standards differ from coding's lower bar.

The fundamental evolution of agent capabilities traces through ReAct (2022), which established reasoning and acting as core principles; the failed BabyAGI experiment (2023) that lacked reasoning quality and long context windows; and breakthroughs with reasoning models like Opus 3, o1, and o3. These models succeeded because they titrate compute to problem difficulty and enable better self-healing through extended reasoning. Troyanovsky argues that verifiable rewards helped coding agents succeed, but they represent only one factor alongside high-quality training data and engineering focus.

The core innovation at Basis is the behavior specification framework—markdown files that define how agents should operate, functioning simultaneously as product specs and evaluation rubrics. Unlike relying purely on outcome-based evals (which can pass 100/100 times yet fail in production), behavior specs encode process requirements: for example, agents must cite primary sources rather than relying on pre-training knowledge. These behaviors aren't shown directly to agents but guide context engineering and judge-based evaluation.

Troyanovsky emphasizes that building long-horizon agents requires understanding LLMs as 'magic boxes' with large working memory but no inherent short/long-term memory. Agents must maintain coherence through harnesses, sub-agents, and carefully designed ontologies—the structured representation of the world agents operate within. The Deployed Intelligence team at Basis helps accounting firms transition to agent-augmented work by combining process expertise with agent orchestration knowledge.

Critically, Troyanovsky argues that process verification matters more than outcome verification because companies deploy agents to humans who expect consistency, reliability, and understandable decision-making—not move-37-style hidden optimizations. The behavior specification approach, open-sourced with BrainTrust, enables better signal generation for future reinforcement learning on model weights, though current gains from better self-orchestration exceed benefits from direct model updates.

He stresses that technical moats are temporary; lasting competitive advantages come from business position, embedded workflows, and domain expertise. Context quality (the 'English') affects runtime performance more than code organization, yet engineers often treat code as more precious—an inversion of priorities for agent systems.

Key Insights

  • Passing 100/100 outcome-based evals doesn't guarantee production reliability—an agent getting tax research correct by reading Wikipedia instead of primary sources will fail real-world deployment the same way accounting firms wouldn't hire a human doing that, so process verification is essential
  • LLMs have large working memory but no inherent short or long-term memory, requiring harnesses and agent machinery to maintain coherence beyond the context window—similar to the protagonist in the film Memento who must externalize notes to function despite short-term memory loss
  • Context quality affects agent runtime performance more than code organization does, yet engineers often treat code as more precious than English when the opposite is true for agent systems
  • Coding agents succeeded not primarily because of verifiable rewards but due to three factors: runtime verifiability, low cost of verification, and text-based availability—plus high-quality training data focus by labs and inherent systems thinking from engineering culture
  • Humans already work with nondeterministic systems (co-workers), so agent design should mirror organizational principles—including verification steps, independent review, and deterministic checks—rather than assuming agents will discover better processes than centuries of human practice

Topics

Long-horizon autonomous agentsProcess-based vs outcome-based evaluationBehavior specifications and ontologiesVerifiable rewards and model reasoningContext engineering and harness designReal-world agent deployment in accountingSelf-improvement and reinforcement learningLLM mental models and inference-time learningSub-agents and orchestrationNon-deterministic system design

Transcript

[0:00] Humans are already used to working with nondeterministic systems. It's just those systems are normally their co-workers, not their computers. And in many ways, like companies and processes is all about how do you design a system for nondeterministic entities to coordinate together to solve a problem. And once you realize that, it's like, well, now it's like kind of agent design. Let's say you have 100 evals. Great. They all pass. It looks good. Are you confident that that now generalizes to the real world to production? And our answer has been no. Even if you got it right a 100 out of 100 times, if a person is just getting it right because [0:30] they're going to…

Full transcript available for MurmurCast members

Sign Up to Access

More from The MAD Podcast with Matt Turck

Get AI summaries like this delivered to your inbox daily

Get AI summaries delivered to your inbox

MurmurCast summarizes your YouTube channels, podcasts, and newsletters into one daily email digest.