# The Future of Agents with Harrison Chase

## Executive summary

The industry is shifting from simple task-based LLM interactions to complex, persistent, and always-on AI agents. To manage the growing complexity, reliability, and cost of these agents, the focus must move beyond the model itself and encompass three critical dimensions: the intended behavior (runtime), the observed behavior (improvement loop), and the governed behavior (policy). Langsmith introduces a comprehensive platform to manage this entire lifecycle.

## Key takeaways

- The Rise of Persistent Agents: Persistent agents are defined by four characteristics: they are goal-oriented (optimizing for an outcome, not just a task), always-on (reacting to real-world events/schedules), accumulate context over time, and are multiplayer/multi-surface (operating across different interfaces like Slack and web apps).
- Agent Behavior is Multi-Dimensional: Agent behavior must be managed across three layers: the intended behavior (defined in the runtime), the observed behavior (the improvement loop using traces), and the governed behavior (enforced via policy at choke points).
- The Importance of the Improvement Loop: Reliable agents require a continuous feedback loop. This involves observing agent traces, spotting error patterns, and using those failures to generate test cases and code fixes (Langsmith Engine).
- Tool Use Requires Governance: Tool use must be secured and governed using a Tool Gateway, which tracks the identity of the caller, enforces policies, and maintains a comprehensive audit log, ensuring compliance and control.

## Technical details

- Agent Architecture Layers: An agent is composed of three layers: the Model (LLMs, reasoning, tool calling), the Harness (how the model interacts with the environment, e.g., file system, sandbox), and the Context (application-specific instructions, facts, memory).
- Agent Runtime Components: The Agent Runtime (e.g., Langsmith Deployments) is the infrastructure that runs the agent. It includes features like durable execution (recovering from failure), context hubs, cron jobs, and task queuing/steering for incoming messages.
- Langchain Deep Agents: Langchain Deep Agents is an open-source, model-agnostic base harness designed to be modified via middleware, supporting skills, summarization, context offloading, and sub-planning.
- Memory Management: Memory is complex and involves more than just storage format. It requires the agent to 'take notes' while running, and a separate 'curator agent' (the dreaming agent) to process these notes and update the knowledge base.

## Practical implications

- Build engineers must shift focus from merely making the agent function to ensuring its reliability, scalability, and adherence to business rules.
- The Tool Gateway provides a critical security layer, allowing organizations to enforce permissions (e.g., 'only in DMs') and maintain an audit log for every tool call.
- The concept of 'durable execution' is vital for production agents, ensuring that a long-running process can resume exactly where it failed, rather than restarting from the beginning.
- Trace data is not just for debugging; it is the primary input for the improvement loop, which is used to generate regression tests and fix code.

## Topics

AI Agents, LLM Engineering, Agentic Systems, Observability, Software Reliability, Langsmith, Langchain Deep Agents, Langmith Engine

Source: https://www.youtube.com/watch?v=GojQtxCT3dg
