Harrison Chase is the co-founder and CEO of LangChain. This 46-minute LangChain webinar, published on 20 November 2026, opens with a two-minute LangSmith product reel and then moves into his talk on where agents are heading in 2027, followed by about ten minutes of audience Q&A.
The core claim: a new step change in agents has arrived. After plain LLMs, tool calling, reasoning models and coding agents, teams are now building persistent agents, and building one well takes more than a good model and a good prompt. It takes a harness, a runtime around that harness, a loop that improves the agent from what it actually did, and a governance layer that enforces what it may never do.
Four eras, then persistent agents
Chase frames the last four years as a progression:
- Text in, text out. Single LLM calls. LangChain started about a month before ChatGPT.
- Messages and tool calling. Provider APIs that made conversational apps and sequential tool calls possible.
- Reasoning models. Better models made better agents.
- Coding agents. Agents that act on an environment instead of answering in a single call.
The next step goes by several names: ambient agents (LangChain’s own term from earlier), always-on agents (from an Anthropic post), proactive agents, and persistent agents (a term he first heard from Dylan Patel). He prefers “persistent” because it covers every dimension the others describe. In Q&A he adds that in a few years these will just be called agents.
The four traits of a persistent agent
Goal-oriented, not task-oriented
A task is bounded: “write this email”. The agent finds what it needs, calls a tool and stops. A goal is ongoing: “maintain a blog” or “keep inbox zero”. The agent runs over a long period, tries different approaches, breaks the goal into tasks as it goes and optimises for an outcome.
That shift creates a new discipline he calls goal design. His example is Actively AI, which builds sales agents. They started with one agent per account, the natural split. They got better results by organising agents around the stages common to every account (outbound, early-stage deal progression) instead. Customers found it easier to teach an agent how to do outbound across many accounts than to coach one agent per account, and the learning carried across accounts. The lesson: design goals around the feedback loops your users can actually give.
Always on
A persistent agent wakes up on more than user messages: real-world events, schedules the developer sets, schedules the user sets, and schedules the agent sets for itself. “Waking up” just means a message arrives in the agent’s thread from an event system rather than from someone typing in a chat box.
Learns over time
Working on ambiguous goals over long horizons, the agent has to remember what it did and learned so it stays consistent and keeps making progress. Memory becomes a core part of the design.
Multiplayer and multi-surface
These agents work alongside many people at once. His example is Robin, an internal LangChain agent that several people talk to in Slack at the same time, and that also has a desktop app and a web app. A thread can be picked up from any of the three.
What each trait needs
Chase walks back through the four traits and lists the building blocks:
- Goal-oriented. Prompting that pushes the agent toward the goal and encourages it to explore different paths. An agent that wakes every 30 minutes and repeats the same action makes no progress; it has to know what it did before. Alignment matters at both the prompt and the model level. Give an agent the goal “remove all bugs” and deleting the codebase technically meets it.
- Always on. Crons for background runs, one-off or scheduled. Tools so the agent can manage its own cron schedule and set reminders. Event listeners (a new email, a Slack message). And logic for queueing and steering: when a user message arrives while the agent is busy with a background event, does it wait in a queue or redirect the current run?
- Learns over time. A concept of user memory, agent memory or both. A decision on whether the agent writes to memory directly while running, or writes notes to a buffer that is folded in later by dreaming: a background run that reviews previous runs, notes and other sources, then updates memory.
- Multiplayer and multi-surface. Auth that follows the person, not the thread. If he starts a Slack thread and a colleague replies, the colleague must not reach his Notion or email through it. State has to be reachable from every surface, and the UIs need to show streaming progress.
Three layers: context, harness, runtime
Behaviour comes from the whole system. Chase splits an agent into three layers:
| Layer | What it is | What teams usually do |
|---|---|---|
| Model | Reasoning, tool calling | Use a frontier or open-weight model off the shelf |
| Harness | How the model interacts with the world: tools, the loop, the sandbox or file system | Start from a base harness instead of building one |
| Context | Instructions, facts, feedback, memory, app-specific tools and skills | Bring their own: this is what makes the agent domain-specific |
The harness: Deep Agents
LangChain’s harness is Deep Agents: open source and model-agnostic. Its built-in pieces:
- Tools for the file system, sandboxes and now browsers
- Undifferentiated context management: skills and skill loading, summarisation of long threads, offloading of large tool results, prompt caching
- Human-in-the-loop, for long-running agents that need user feedback
- Planning, subagents and async subagents for delegation
It is built as a base harness: you are meant to modify it, either through middleware that hooks into the agent loop or by forking the code. It is good at coding but not designed as an end-user coding tool.
The runtime: what sits around the harness
The harness covers only about half of the requirements above. The rest is infrastructure outside the core loop, which Chase calls the agent runtime:
- Durable execution: if a run fails halfway, it resumes from where it failed instead of starting over
- APIs that accept incoming messages and decide whether to reject, queue or steer them
- A scheduler for crons and reminders, plus tools so the agent can use it
- Storage for threads, progress and history that both the app and the agent can reach (files on a laptop are fine; in the cloud this needs a real store)
- Reliable event streaming that can be resumed across devices: start in Slack, continue in the desktop app
- The environment the agent acts on, such as a sandbox
In LangSmith this is LangSmith Deployments, which he describes as an agent server. It bundles any harness with sandboxes, a context hub for persistent skills, cron jobs, threads, resumable streaming, auth, a task queue with four strategies for multitexting (incoming messages while a run is active), and checkpoints.
One level up sits Managed Deep Agents, which bundles the Deep Agents harness with that infrastructure. You define only the agent’s logic: instructions, skills, memory, schedules, tools and the surfaces people use. Use the agent server to run any harness; use Managed Deep Agents for the shortest path.
Intended, observed and governed behaviour
The runtime defines the intended behaviour: what you want the agent to do. Telling an agent what to do gives no guarantee it will do it, so two more pieces are needed to run agents reliably at scale.
Observed behaviour: the improvement loop
You observe what actually happened and feed it back:
- Test every dimension. Right tool calls, right messages, correct state edits. And not too much: an agent that wakes every 30 minutes and messages the user every time is spam.
- Grade traces and end state against rubrics. Was the incoming signal relevant? Was the research sound? Online evals grade live runs without ground truth; offline evals run against ground truth.
- Grade signal handling. New for persistent agents: the agent should act when an event is worth acting on and stay silent when it isn’t. Noise and missed opportunities both count as failures.
- Turn failures into regression tests. Production traces reveal failures; each failure becomes an eval that acts as a unit test for future changes.
In Q&A he expands on how to gain confidence that a change really helps: evals (offline before a change, online for A/B tests and regression), traces as the system of record, and an agent to spot patterns. LangSmith’s Engine does that last part. It watches traces, finds issues, then writes fixes and evals for review. Under the hood it is a coding agent with a particular set of skills, tools and CLIs. With thousands or millions of traces, nobody can read them by hand.
Governed behaviour: enforce at the choke points
Some things the agent must never be allowed to do, and a prompt can’t guarantee that. A prompt is a suggestion: the agent can ignore it or be prompt-injected. Governance enforces policy, identity and approval at the choke points: tool calls and network requests, including calls to the model.
Permissions depend on context: who is acting, what the action is, and which surface the agent is on. His real example is LangChain’s internal Slack agents. In a DM, the agent may send email in your personal scope. In a shared channel it may not, because others are present and the content may be sensitive.
LangSmith puts two gateways at those choke points:
- LLM gateway: cost controls, model access, fallbacks.
- Tool gateway: secures and governs tool use for any agent, including coding agents and other frameworks.
Together these are what Chase means by own your intelligence: owning an agent’s behaviour across all three dimensions. Specify what it should do, observe whether it does it, and enforce what it may do.
What shipped in LangSmith this week
He closes the talk with three releases.
Trace data control
Traces drive the improvement loop but carry sensitive data, and customer contracts may forbid developers from reading inputs and outputs.
- Masked inputs and outputs. A trace can show only its skeleton: which models ran, token counts, cost, tools. That can be the default view for developers.
- User groups. Who can see inputs and outputs, or access certain traces at all, is now set per team instead of per user.
- Trace-level access policies from metadata. A rule such as “traces with metadata key X = Y are fully visible to group Z”. The intended pattern: everyone sees skeletons, and when one customer reports a problem, a small group gets full visibility into that customer’s traces only.
LangSmith for coding agents
A dedicated coding agent type. Connect GitHub to tie coding-agent spend to outcomes (which traces led to which PRs), then view cost per merged PR and cost over time, grouped by user, model or PR type. Threads are classified by kind, such as bug fix or exploration. Integrations cover the popular coding harnesses, including Claude Code, Pi, OpenCode and Codex.
Tool gateway
The gateway in the diagram above. It tracks the identity behind each call, attaches an OAuth token, checks policies and guardrails, writes an audit log of which agent called which tool on whose behalf, and forwards to built-in tools, remote MCP servers or your own tool servers.
Q&A highlights
- Use cases beyond assistants. Every use case will become a persistent agent, he says. Go-to-market is first: Actively, Clay, and LangChain’s own internal go-to-market agent. LangChain also runs Content Studio, a marketing agent that maintains blog links and schedules his weekly Friday launch roundup post, and coding agents for reviews and incident response that learn from past incidents.
- Memory at scale. The squeeze is compute, not memory storage: persistent agents need sandboxes, which is why LangSmith includes them (on Google infrastructure, with other providers integrated). Storing memory is easy and most memories are small. The hard part is deciding what to remember and keeping it fresh.
- Agents taking real actions, such as payments. You need an audit log of every action, a tool policy layer (allow, deny, or allow with human approval, possibly semantic rules on inputs), and model alignment. Alignment matters far more for agents that run unseen in the background than for short tasks.
- How to architect memory. Storage format matters less than you’d think. Skills are procedural memory with their own format; general knowledge might live in Markdown, a wiki or a graph database. Two questions matter. First, can the agent write while running? LangChain leans toward letting it always take notes, so it doesn’t have to rediscover a gap later. Second, are those notes visible immediately, or only after a curator agent (the dreaming agent) folds them in on a schedule? For skills, the best source for that curator is agent traces. For general knowledge, also look across Notion, Slack and other tools. He calls the result a knowledge factory, and expects much of this to be “bitter lessoned” into a coding agent with the right skills and tools.
- One long thread or many? No single right answer. A product can look like one long thread while using separate threads underneath with a strong memory system. Either way, give the agent search across previous messages or threads.
Try it yourself
The fastest way to see the harness layer is the Deep Agents quickstart: a research agent built on the open-source harness, optionally traced to LangSmith. Source is at langchain-ai/deepagents.
1. Install Deep Agents
mkdir deepagents-demo && cd deepagents-demo
python3 -m venv .venv
source .venv/bin/activate
pip install deepagents
How to check it worked: pip show deepagents prints Name: deepagents and a version.
2. Set your keys
Set the key for your model provider. The tracing variables are optional and need an agent created once in LangSmith, which gives you the agent ID.
export ANTHROPIC_API_KEY="your-api-key"
# Optional: LangSmith tracing
export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-langsmith-api-key"
export LANGSMITH_AGENT_ID="<your-agent-id>"
export LANGSMITH_AGENT_ENVIRONMENT="local"
How to check it worked: env | grep -E 'ANTHROPIC|LANGSMITH' | cut -d= -f1 lists each variable name you set.
3. Write the agent
Save this as research_agent.py. It uses Anthropic’s built-in web search, so no extra search key is needed:
from deepagents import create_deep_agent
internet_search = {"type": "web_search_20260209", "name": "web_search"}
research_instructions = """You are an expert researcher. Your job is to conduct
thorough research and then write a polished report.
You have access to an internet search tool as your primary means of gathering
information."""
agent = create_deep_agent(
model="anthropic:claude-sonnet-5",
tools=[internet_search],
system_prompt=research_instructions,
)
result = agent.invoke(
{"messages": [{"role": "user", "content": "What is langgraph?"}]}
)
print(result["messages"][-1].content)
create_deep_agent gives you the harness from the talk: planning, file system tools, subagents and context management are already wired in, and you supply the context layer (prompt and tools).
How to check it worked: python -c "import ast; ast.parse(open('research_agent.py').read()); print('ok')" prints ok.
4. Run it
python research_agent.py
How to check it worked: the terminal prints a multi-paragraph report on LangGraph. If tracing is on, open your agent in LangSmith: the newest trace shows the model calls, the web search tool calls and any subagent delegation as a tree.
How it ties together
- Persistent agents are goal-oriented, always on, learning and multiplayer. Each trait needs specific prompting, harness features or infrastructure.
- Goal design matters as much as prompting: organise goals around the feedback users can actually give.
- An agent has three layers. You bring the context; you start from a base harness such as Deep Agents; you run it on an agent runtime with durable execution, crons, queueing, state and resumable streams.
- The runtime only sets intended behaviour. Traces show observed behaviour, and failures become evals that gate the next change.
- Governed behaviour is enforced at the choke points (LLM and tool gateways), never in the prompt, and permissions depend on who acts, what they do and where.
- Memory is mostly a curation problem. Let agents take notes while running, and let a background dreaming agent curate them.
Sources: the webinar on YouTube, the Deep Agents quickstart and the deepagents repo.