Host: Hello everyone, this is Best Partners. AI in 2026 may no longer be just a chatbot Q&A robot. Sequoia Capital, in its article "2026: This is AGI," provided a definition: the core of AGI is not eloquence, but the ability to get things done. And the key carrier of this capability is what we will discuss today: long-term agents. In 2023, the explosion of AutoGPT gave us the first glimpse of AI's potential for autonomous action, but the technology at the time could only stay at the proof-of-concept stage. By 2026, the situation is completely different. The leap in model capabilities and the maturity of supporting toolchains have allowed long-term agents to truly move from the lab to industrial application. As a core driver of this transformation, Harrison Chase, founder of LangChain, stands at the forefront of agent infrastructure, engaging in a deep dialogue with Sequoia Capital's Sonya Huang and Pat Grady, revealing the underlying logic, technical architecture, and future industry trends of the long-term agent explosion. Today, we will use this interview to discuss the origins, core details, and application prospects of long-term agents.

Host: First, we need to understand a core question: What is the essential difference between long-term agents and the AI we used before? Past AI, whether it was ChatGPT or various vertical Q&A tools, was essentially an instant responder. You input a question, it gives an answer based on the context, the conversation ends, and the task terminates. They are like talkative individuals, good at explaining and describing, but find it difficult to independently complete complex tasks that require multiple steps and long-term progression. Long-term agents, however, are completely different. Their core characteristics are autonomous planning, long-term operation, and goal orientation. You don't need to guide them step-by-step; just provide a clear goal, and they can autonomously loop in the background, going through the entire process from thinking to planning, to action, and to observation, spanning hours, days, or even longer, gradually advancing the task to ultimately produce a finished result.

Host: Chase explicitly stated in the interview that long-term agents are finally starting to truly work. Behind this are two key factors working together. The first key factor is the qualitative change in model capabilities. The core reason AutoGPT failed to gain widespread adoption in 2023 was that the models at the time were not smart enough, lacked sufficient reasoning ability, could not make correct decisions in complex tasks, and struggled with context management in long-term tasks. After two years of iteration, whether it's OpenAI's GPT-5.2 series, Anthropic's Claude Opus 4.5, or Google's Gemini 3 series, they have all achieved breakthroughs in reasoning, tool usage, and long-context understanding. Claude Code, in particular, has been specifically optimized for scenarios like code editing and file handling, giving models the fundamental ability to operate computers autonomously. The second key factor is the maturity of supporting infrastructure. The core here is Harness and Scaffolding, referring to the refinement of software shells and auxiliary frameworks. Chase explained that in early agent development, we relied more on Scaffolding, which is the auxiliary code structure built around the model. It could help guide the model's output and manage simple workflows, but lacked complex autonomous planning capabilities. Now, we have entered the Harness era. This software environment not only encapsulates the model but also integrates planning tools, file system interaction capabilities, and best practices, forming a ready-to-use, strongly pre-set system. Simply put, Scaffolding used to be about building a frame for the model to stand on, while Harness now provides the model with a toolbox to get work done.

Host: The combination of these two factors has led to a rapid explosion in the application scenarios for long-term agents. The most typical area of explosion is programming. Chase, as a developer who uses these tools daily, directly states that programming is where long-term agents have the most cases and are the most mature. Now, if you submit a development request, such as building a user login system with SMS verification and password encryption, a long-term agent can autonomously plan the development steps: first create the project structure, write the core code, debug dependencies, generate test cases, and finally submit a complete code merge request for human developer review. This model of producing a draft followed by human optimization has become the daily routine for many tech companies. Besides programming, two other scenarios are equally noteworthy. The first is AI SRE. For instance, Traversal, a company invested in by Sequoia, has AI SREs that can autonomously handle long-term system operations tasks, delve into server logs, diagnose potential failures, and even automatically fix simple software vulnerabilities, compressing hours of troubleshooting work by engineers into tens of minutes. The second is scientific research. Long-term agents can autonomously search literature, organize experimental data, analyze research trends, and ultimately generate a structured draft of a research report. Researchers only need to supplement details and verify conclusions based on this draft. Chase specifically emphasizes that the core value of long-term agents is providing high-quality drafts for complex tasks. They don't need to achieve 99.9% reliability, as human oversight is still required for final checks on complex tasks, but they can handle over 90% of repetitive, procedural work, freeing humans from tedious labor. For example, Klarna in the financial sector, a buy-now-pay-later payment company, has implemented a human-AI collaboration model. Complex user inquiries that frontline AI cannot handle are not directly escalated to human customer service. Instead, a background long-term agent first generates a summary report detailing the cause and effect, including user requests, previous communication records, potential solutions, and more. Human customer service representatives can then quickly follow up after receiving the report, significantly improving handling efficiency.

Host: To understand the explosion of long-term agents, we must also grasp their underlying architecture, especially the evolution from Framework to Harness, which Chase repeatedly emphasizes. This is not only LangChain's development path but also a technical trend for the entire agent industry. First, we need to clarify the distinction between three core concepts, which often confuse many practitioners. The first is the model, commonly known as the large language model. Its essence is simple: input tokens, output tokens. Whether it's GPT-5.2, Claude Opus 4.5, or Gemini 3 Pro, the core function is understanding text and generating text. This is the brain of a long-term agent, but a brain alone is not enough. The second is Framework. This was LangChain's early core positioning, an abstraction layer built around the model. Its characteristic is being un-pre-set, with its core value being flexibility, allowing developers to easily switch between different models, add tools, and connect to vector databases and memory modules. For example, using LangChain's framework, you can connect to OpenAI's model today and switch to Anthropic's model tomorrow without significant code modifications. However, the framework's problem is also evident: it only provides parts, and you need to assemble them into a complete system, leading to high development costs for complex tasks. The third is Harness. This is the core architecture of the long-term agent era. For instance, Deep Agents launched by LangChain is a typical example based on Harness. Its characteristic is strong pre-setting, believing this is the correct way to do things, thus integrating planning tools, file system interaction capabilities, sub-agent scheduling mechanisms, etc., making it a ready-to-use complete solution. If Framework is a pile of high-quality Lego bricks, then Harness is a pre-assembled Lego model that you only need to fine-tune according to your needs to use directly.

Host: Chase revealed in the interview that the core competitiveness of Harness comes from three key technologies. The first is compression. Long-term agents run for a long time, and even the largest models today have limited context windows. When a task progresses to a certain stage, the context will be full, requiring trade-offs: which information to keep in context and which to temporarily store. For example, previous conversation logs and tool call results might need to be compressed into summaries for the context, while raw data is stored in the file system for retrieval when needed by the model. This sounds simple, but determining the importance of information and balancing compression efficiency with information completeness are core challenges in Harness design and a focus of current cutting-edge research. The second is file system interaction. Chase is a staunch advocate for file system priority, believing that file system permissions will become standard for all agents. Why? Because the file system is the best medium for managing long-term task data. Models can store intermediate results, raw data, and planning proposals in files, avoiding context overload. Furthermore, the structured storage of the file system makes it easier for models to trace historical operations and reuse previous achievements. For instance, a research agent can store retrieved literature as PDF files, data analysis code as Python scripts, and draft reports as Markdown files. These files can then be directly invoked when advancing the task later. LangChain has even introduced the concept of a virtual file system, supported by databases like Redis at the backend, offering higher stability and avoiding the security risks of real file systems. The third is the scheduling of sub-agents and skill modules. A complex task often requires multiple capabilities, such as generating an industry research report, which requires literature retrieval, data statistics, text writing, and formatting skills. The role of Harness is to break down these skills into different sub-agents, orchestrated by the main model. The main model is responsible for planning the overall workflow, then assigning the literature retrieval task to the retrieval sub-agent, the data statistics task to the data analysis sub-agent, and finally consolidating the results from all sub-agents to generate the final report. The key here is collaboration: complete information must be passed between the main model and sub-agents to avoid situations where a sub-agent does a lot of work, but the main model only receives a response like "see above." Current open-source Harness systems often feature system prompts hundreds of lines long, primarily aimed at solving these collaboration issues.

Host: The combination of these three technologies enables Harness to support long-term agents. Industry practices also demonstrate the importance of Harness. The current most authoritative AI Agent terminal capability leaderboard, Terminal-Bench 2.0, shows significant performance differences for the same model when powered by different Harness systems. For example, OpenAI's GPT-5.2, within Factory's Droid Agent Harness, achieved an accuracy of 64.9%, ranking first. In other companies' Harness systems, the accuracy might be around 60%. Notably, top players on the leaderboard include not only model providers like OpenAI and Anthropic, but also third-party startups like Factory and JetBrains. This indicates that by deeply understanding model characteristics, third-party developers can significantly enhance performance at the Harness level. In this domain, model vendors do not possess an inherent advantage. Factory's Droid Agent is a prime example. Based on models like GPT-5.2 and Claude Opus 4.5, it ranked first on Terminal-Bench 2.0 with an accuracy of 64.9% across 89 real-world terminal tasks, including code compilation, model training, server setup, and bioinformatics analysis. Its success lies primarily in its Harness design, which fully leverages GPT-5.2's training advantages in command-line operations while optimizing context compression and sub-agent scheduling mechanisms, enabling the model to efficiently handle long-term, multi-step terminal tasks. Chase also mentioned that the evolution of Harness and model evolution are in a co-evolutionary relationship. Current models are well-adapted to file systems and command-line tools because their training data includes extensive code and command-line operation data. The development of Harness, in turn, generates more interaction data, which further promotes model optimization. Two years ago, we couldn't have predicted that file system-based Harness would become mainstream, as models at the time were not sufficiently trained for these scenarios. Now, the mutual advancement of models and Harness has finally enabled the large-scale deployment of long-term agents.

Host: During the interview, Pat Grady posed a forward-looking question: "Is a Coding Agent a subcategory, or should all agents essentially be Coding Agents?" The core of this question lies in exploring the path to achieving general AI. If the goal of AI is to make computers work, and code is the most precise and universal way to control computers, then is a Coding Agent the ultimate form of general AI? Chase's thoughts on this are clearly profound. He first clarifies a prerequisite: building long-term agents requires granting them file system permissions, and programming ability is essentially an extension of file system permissions. File systems can store data, while code can operate on data, run tasks, and implement complex logic. For example, a finance agent can write scripts using code to automatically fetch stock data, calculate moving averages, and generate visualizations. A research agent can write data analysis programs to process experimental data, fit models, and output statistical results. These operations are difficult to achieve precisely with natural language instructions, but code allows for zero ambiguity. However, he also points out that programming agents and agents with file system permissions are not entirely equivalent. For instance, LangChain's virtual file system can achieve data storage and retrieval without the model writing code, meeting the needs of some simpler scenarios. But for complex long-tail use cases, programming ability is irreplaceable. You cannot run a machine learning model with a virtual file system, nor can you build a web server with it; these require code. More importantly, programming itself is a universal tool. Whether in finance, research, healthcare, or education, any task involving complex process automation, data processing, or system construction relies heavily on programming. Chase even suggests that non-programming tasks can also be accomplished through writing code, making code a good universal means. This leads to a key conclusion: Coding Agents may be the closest form to general AI currently, as they are not limited to a specific vertical domain but use code as a universal language to interface with all computer systems and tools, achieving complex cross-domain tasks. Of course, this does not mean all agents must write code. For simple, standardized tasks, natural language instructions combined with file systems are sufficient. However, for long-term, highly complex, and precise tasks, programming ability will become the core competitiveness of long-term agents. Currently, industry trends support this view. Top players on the Terminal-Bench 2.0 leaderboard are almost all programming-based agents, and the popularity of products like Claude Code and Amp Code indicates strong market demand for AI programming capabilities. More importantly, the capability boundaries of Coding Agents are continuously expanding, from generating single-file code to developing multi-file projects, and even building complete SaaS applications. Coding Agents are gradually gaining the ability to solve complex engineering problems end-to-end. Chase admits this is a current, phased judgment. Whether a more universal and efficient computer control language than code will emerge in the future remains unknown. But for now, Coding Agents represent a core direction for long-term agent development and the most likely path to achieving general AI.

Host: Many traditional software developers are puzzled when they encounter long-term agents, thinking, "Isn't this just an upgraded version of automation scripts?" However, Chase explicitly points out that there are fundamental differences between building long-term agents and traditional software. These differences are not only technical but also lie in development philosophy, iteration models, and core objectives. The first core difference is the origin of logic. The logic in traditional software is fully visible and controllable; all processes, judgments, and operations are written in code, allowing developers to precisely predict the software's behavior in any scenario. In contrast, a significant portion of long-term agent logic comes from the model code provided by the framework, such as the structure of Harness and how tools are integrated. The specific decisions, plans, and operational steps are autonomously generated by the model based on context and goals. This means you cannot infer an agent's behavior in a specific scenario just by looking at the code; you must run it and observe its performance. This non-deterministic black-box system characteristic poses significant development challenges. For example, for the same requirement, an agent might generate completely different operational steps in different contexts, or even within the same task, the first thirteen steps might go smoothly, but the fourteenth step deviates due to context changes. This is also why LangSmith's Tracing feature is so popular. It can reproduce every step within the agent: the model's thought process, tool call results, context changes, and file modification records. Developers can use Tracing to pinpoint decision deviations precisely, rather than debugging traditional software by looking at code. The second core difference is the Source of Truth. In traditional software, the source of truth is the code; the software's behavior is solely determined by the code. As long as the code remains unchanged, the behavior remains unchanged. For long-term agents, the source of truth is code plus Tracing. Code defines the basic rules, while Tracing records the agent's actual behavior and context changes. This implies that agent development and testing cannot rely solely on offline unit tests but must involve online testing. Only by exposing the agent to real-world inputs and observing emergent behavior can problems be identified and models optimized. More importantly, Tracing is becoming a core pillar of team collaboration. In traditional software teams, when encountering issues, people say, "Check the code on GitHub." In agent development teams, they say, "Let's look at the Tracing." For instance, if a user reports that an agent misclassified an email, developers don't need to inspect the code; they should use Tracing to examine the agent's thought process: what keywords did it extract? Based on what rules did it classify? Did it miss any crucial information? This information can quickly pinpoint the root cause, which might be unclear prompt guidance or the model's misinterpretation of certain keywords, rather than an issue with the code itself. The third core difference is the iteration model. Traditional software iteration is goal-oriented and behavior-predictable. Developers set functional goals, write code to implement them, test, and release. The software's behavior is known before release. Long-term agent iteration, however, is goal-ambiguous and behavior-emergent. You might know you want to build an email classification agent, but you cannot predict its performance when faced with various complex emails (e.g., those with attachments, in multiple languages, or with ambiguous content). Therefore, agent development requires more iterative feedback. After release, through collecting user feedback, analyzing Tracing data, and optimizing prompts and Harness, followed by further testing, this cycle repeats until the agent's performance meets expectations. The core support for all of this is Memory. Chase repeatedly emphasizes the importance of memory in the interview. If a system can learn autonomously, it reduces the frequency of developers manually modifying system prompts. Agent memory is essentially long-term context engineering; it records past interaction history, task experiences, lessons learned from mistakes, etc., enabling agents to generalize from past experiences in subsequent tasks. For example, if an email agent remembers that the user always categorizes work report emails into the important folder, it will automatically classify similar emails next time. If it remembers that the user previously corrected the classification of meeting notices and training notices, it will make more accurate judgments in the future. Chase also shared a personal experience: he previously built an email agent using LangChain, accumulating significant memory. Later, he wanted to migrate this agent to LangSmith Agent Builder. Due to the loss of old memories, even with identical prompts and tools, the new agent's experience was far inferior to the old one. This case fully illustrates that memory is the agent's core moat. An agent that has undergone long-term refinement and internalized specific task patterns and background memories possesses a competitiveness that cannot be matched by agents built from scratch.

Host: If memory is the agent's experience repository, then the evaluation system is the agent's self-correction mechanism. Evaluating traditional software is simple, using programmatic assertions like "if input A, is output B?" to determine if functionality meets standards. However, long-term agents perform human-like tasks, such as generating reports, writing code, and handling operational issues. Evaluating these tasks is difficult with simple binary rules; human or human-like judgment is necessary. This leads to two core methods for evaluation systems. The first is direct human evaluation. For instance, in LangSmith, developers can provide feedback on agent behavior through Annotation Queues, such as "this step was done well," "classification error here," or "prioritize this task." These natural language feedbacks are recorded in Tracing and become the basis for optimizing the agent. For high-value, high-risk scenarios like generating financial reports or processing medical data, human evaluation is indispensable, as agent drafts require human oversight to prevent serious errors. The second method is using large models as judges. The core idea here is to use a more powerful large model to assess whether the agent's behavior meets standards. For example, using GPT-5.2 to evaluate the correctness and efficiency of code generated by a programming agent, or Claude Opus 4.5 to assess the rigor and completeness of a research report generated by a research agent. However, a crucial prerequisite is that the judging model must be aligned with human judgment. If the large model's evaluation criteria differ from human standards, the results are meaningless. To address this, LangSmith introduced an alignment evaluation feature. Humans first annotate a portion of Tracing data to create a sample library of correct behaviors. This library is then used to train the judging model, teaching it human evaluation standards. For example, if humans annotate that "code must include error handling logic to be compliant," the judging model will use this standard to evaluate the agent's generated code. This approach of human-annotated calibration combined with automated model evaluation ensures accuracy and improves efficiency, making it highly suitable for large-scale agent iteration. More importantly, the evaluation system serves not only as feedback for developers but also as a basis for agent self-improvement. Chase calls this iterative self-improvement. By reviewing Tracing data, reflecting on past actions, and then automatically modifying prompts, adjusting planning logic, or optimizing tool usage, agents become smarter with use. LangSmith Agent Builder is a prime example. This tool allows users to describe requirements in natural language, such as "Create an assistant that can read Gmail, automatically classify emails, and draft replies," and it can automatically generate a complete agent. Even cooler, it possesses self-improvement capabilities. When you interact with the agent and say, "Meeting notifications should be classified as urgent, not regular," the agent automatically modifies its instruction file and will classify emails according to the new rule next time. LangChain also plans to add a "dormant period computation" feature, allowing agents to run automatically each night, review the day's Tracing data, summarize lessons learned, update their status, and achieve unsupervised self-optimization. Of course, this self-improvement is not entirely without human intervention. Chase emphasizes that the ideal state is for the agent to produce a draft (e.g., modify prompts), which humans then review to ensure it doesn't go off track. After all, an agent's self-improvement might lead it in the wrong direction; it might over-optimize one function, causing others to fail, or misunderstand user feedback and make inappropriate modifications. Therefore, Human in the loop is a necessary safeguard for agent self-improvement and is currently the most realistic and secure model.

Host: After discussing technical architecture and self-improvement, we come to our most pressing questions: In what form will future long-term agents appear in our work and lives? How will we interact with them? What will be their core competitiveness? Chase's first answer is memory. He stated directly in the interview, "Memory is the true moat." The core of this viewpoint lies in the value of long-term refinement. An agent's value is not only in its initial capabilities but also in its process of understanding you better with use, gradually becoming your exclusive assistant, a sense of exclusivity that newly built agents cannot replicate. Of course, the value of memory has its limits. For example, although ChatGPT has added a memory function, many users don't use it often because they use ChatGPT for one-off tasks, like asking a coding question or looking up travel advice, where tasks are unrelated, limiting the role of memory. However, for long-term, high-frequency, personalized tasks like research, office work, or financial analysis, the value of memory is immensely amplified. Chase's judgment is that in vertical scenarios, memory is definitely a major trend. Beyond that, future long-term agents will not be purely synchronous or purely asynchronous but a hybrid form of synchronous and asynchronous modes. Why is an asynchronous mode needed? Because long-term agents run for a long time; it might take hours to generate a research report, or days to complete a software project. During this process, users cannot wait indefinitely, so the default should be asynchronous. After you issue a task, the agent runs in the background and notifies you upon completion, after which you proceed with further operations. Project management tools and emails serve as good references for asynchronous management; they allow you to clearly see task progress and status without constant real-time attention. Then why is a synchronous mode still necessary? Because when the agent produces results, you need immediate feedback. For instance, if the agent's generated report contains errors, you need to point them out immediately; if the agent's code has vulnerabilities, you need real-time debugging. In such cases, synchronous communication becomes essential. You can chat directly with the agent, identify the problem, and the agent can make real-time modifications, forming a feedback-to-correction loop. Chase also mentioned a key detail: current agents are not just talking; they are actually modifying states, such as files in the file system. This implies that future interaction interfaces must be visually state-aware. Just as programmers rely on IDEs to view code, you need to know which files the agent has modified, which parameters it has adjusted, and which tasks it has executed. This visualization of state is the core of the interaction experience. Anthropic's Cowork has provided a good paradigm: it allows setting up a directory as a shared workspace, accessible by both the agent and the user for viewing and modifying files. This model establishes a clear mental model: we are collaborating on a shared state. Whether it's local files, Google Drive, or Notion, the visualization of shared state is central to interaction. Based on the needs for hybrid interaction modes and state visualization, the UI for future long-term agents will completely abandon the current pure dialog box format and shift towards a state management interface. This interface will comprise three core components: First, a task management module, referencing tools like Jira and Kanban, displaying tasks the agent is currently handling, their progress, and priorities. Second, a shared state visualization module, showing file systems, code repositories, data tables, etc., allowing you to intuitively see the agent's operational results. Third, a synchronous communication module with built-in chat functionality, enabling real-time interaction and feedback when needed. In simple terms, the future long-term agent UI will be more like a combination of a project management tool, an IDE, and a chat application. It will no longer be just a communication window but a platform for task management and state monitoring. Only this interface design can perfectly accommodate the hybrid interaction model of asynchronous management and synchronous feedback, allowing users to efficiently manage multiple long-term tasks and promptly resolve issues encountered by the agent.

Host: Finally, Chase explicitly states that a code sandbox will absolutely be a core component of the future. The purpose of a code sandbox is to provide a secure, isolated execution environment for agents. Agents can write code, run scripts, and test programs within the sandbox without affecting the security of external systems. He also offered three judgments: First, file system access will be standard for all agents; second, programming ability is the core competitiveness of long-term agents; third, browser access is currently not mature enough. Although there have been attempts, such as allowing agents to control browsers via command line, the model's accuracy and stability still need improvement. This implies that future long-term agents will all come with a built-in code sandbox, possessing file system access and programming capabilities, allowing them to safely execute complex tasks in an isolated environment. Browser access, however, may become a supplementary capability after further model optimization. Sequoia Capital states that AGI is the ability to get things done, and long-term agents are a crucial step towards achieving this capability. 2026 may mark the beginning of the AI actor era. We have reason to believe that in the coming years, long-term agents will completely reshape our work and lives, truly making AI our best partner. Thank you for watching this episode; see you next time.