.@hwchase17 kicked off Interrupt London with a keynote on where agents are headed, and why every org should own their intelligence.

🔴 Full talk: https://t.co/4K7KoeiHlb

⏯️ Every session, on demand: https://t.co/hL8WUWHbjG https://t.co/FewQOqVRW8

LangChain Keynote: The Future of Agents & “Owning Your Own Intelligence”

TL;DR: Harrison Chase’s Interrupt London keynote traces the evolution of agents, lays out three pillars of “owning your own intelligence” — openness, compounding, and governability — and introduces LangChain’s tech stack spanning runtime, observability & eval, and intelligence layer, along with the new Deep Agents framework and Managed Deep Agents.

Conference Kickoff: From San Francisco to Three Cities

Interrupt took place in London. Last year the conference was only in San Francisco; this year it expanded to three cities — San Francisco, New York, and London.

Before diving into the main content, the speaker first walked through how the industry got to where it is today:

• 2023: LangChain had just launched, and much of the work was helping people prototype agents — that was a brand-new, exploratory space everyone was thinking about at the time.
• 2024: Applications started going live, but simpler ones — single LLM calls, chains of LLM calls, chatbots.
• 2025: People began truly exploring agents. And just over the past year has been the year agents really came alive and started transforming the application layer — vast numbers of agents were built across every vertical use case and every layer of the stack.

Key Insight: It’s Not Just the Model That Makes Agents Work

The key thing about these agents is that they’re not just an LLM. The LLM is certainly the core driver, but what really makes application-layer agents take off and actually work is everything around the LLM — the system surrounding it.

Many companies have built harnesses around LLMs, and that’s exactly what makes agents truly work. Three examples were cited in the talk:

• Monday: Built their own agent and established a continuous feedback loop tied to evals, iterating and improving over time.
• Harvey: Fine-tuned models for specialized tasks — not just the model itself, but the entire system around it, including the system used to fine-tune the model.
• Orange: Built specialized harnesses with governance baked in; governance was a key part of what made that agent function properly.

In summary, what actually works is everything around the model: a harness with skills, tools, context, controls, and governance. And precisely because this specialization is happening — taking a model and building a system around it to make it truly effective in a specific domain — “owning your own intelligence” is so important.

Why “Owning Your Own Intelligence” Is Becoming Increasingly Important

The talk identified three trends driving this demand:

1. Cost: AI tool adoption is at an all-time high, and costs have surged. If you can’t take control of the entire agentic system in some form, costs will spiral out of control.
2. Open-source models: Companies like NVIDIA, Kimi, and DeepSeek have released high-performing open-source and open-weight models that can be used at lower cost and post-trained for true customization.
3. Data: This is the biggest factor driving the vertical agents that truly make an impact. When you create a vertical, differentiated experience, the data you bring, the context, and the knowledge that shapes the harness are what truly set it apart from something that just uses ChatPPT or Claude.

LangChain’s mission is to enable every company to own its own intelligence, believing this is exactly what’s needed to give birth to thousands of vertical or enterprise-specific harnesses.

Three Pillars of Owning Your Own Intelligence

Open

This refers to the entire agent architecture itself: the model, the harness, and the context.

• Open model: Not just open-weight models — more importantly, model optionality. You should own the ability to choose which model to use: which is best, fastest, cheapest, best suited to your domain.
• Open and controllable harness: How you enforce a general-purpose LLM to act in a particular way lives in the harness. Open source is a good way to achieve controllability; if the harness isn’t open, you can’t effectively manipulate those dials.
• Open context: Context can come from anywhere — existing data sources, APIs, accumulated memory. Having a harness that works with any context source is essential to truly owning this agent.

Compounding

Building the initial version of an agent is relatively easy, but it’s almost never mature enough to ship to millions of users. How do you improve that agent over time? You want that agent’s intelligence to compound over time — whether that’s through observability to manually find and fix issues, or automatically through things like memory.

Governable

This is critically important for internal enterprise agents in production: who do they act on behalf of? What does it cost to run them? How do you know what’s happening? Agents will absolutely transform how enterprises operate, but you must have governance over them — you need to know who they’re acting on behalf of.

From Organization to Process: How to Achieve “Owning Your Own Intelligence”

No single measure drives this shift — it’s a combination of many, spanning three dimensions: people, process, and technology.

People: Three Types of Roles

1. Core GenAI platform team: Agent experts who build the technology and typically the processes for the rest of the company to use and benefit from.
2. Agent engineers in each business unit: Those who take that technology and make it truly work for specific use cases.
3. Non-technical people, non-developers: Absolutely involved in the agent-building process — they often know best what “good” looks like for a specific domain or problem.

Process: Spin the Iteration Flywheel

Building agents is a deeply iterative process. The first version won’t be the one that successfully serves millions of users, so you need to kick off and truly run this lifecycle: build a version → test it fast → deploy it to a small set of users quickly → monitor → bring the lessons back to the build step. The speaker noted that the best teams they’ve seen are the ones that spin this flywheel as fast as possible.

Technology: Three Key Components

1. Runtime: How you build and deploy agents, including open-source libraries and deployment solutions.
2. Observability and eval: Core to the compounding loop.
3. Intelligence Layer: A recently added layer. Every part of the software development lifecycle (SDLC) is being automated, and agent building should be too — not just building tools that help agent engineers spin the flywheel faster, but also building intelligence to help do some of the work for them.

Runtime: A Layered View & Deep Agents

From a layered perspective, building agents involves three layers:

• Business logic: Instructions, tools, skills, and possibly hooks to modify parts of the harness. This is something LangChain can never provide — it’s domain-specific content that belongs to your team.
• Harness: Everything around the model — connecting the model to external data sources, compute, context, and business logic.
• Infrastructure: The underlying foundation that powers it all.

Deep Agents is LangChain’s newest open-source framework, focused on what a solid foundational harness should look like. It’s designed to be easily modified and built upon, while including many general-purpose primitives:

• Execution environment: Can be a file system, a full sandbox, or a lightweight code interpreter
• Context management: Best practices for working with these models
• Skills and memory: Summarization as conversations get long, context offloading for very large tool calls
• Prompt-cache-friendly architecture
• Steering harness behavior: Such as human-in-the-loop
• Planning and sub-agents: Can spin up small agents to do things

Of course, you can also build more fine-grained solutions yourself using LangGraph and LangChain.

Infrastructure: From Local to Cloud

The talk specifically highlighted: future agents won’t just run on your laptop for you — they’ll run in the cloud, work in the background, be proactive, always-on, multi-tenant, and serve many users.

Transitioning from running purely locally to running in the cloud requires a full infrastructure stack. These components are all being built into LangSmith:

• LangSmith Deployments: Package your agent and deploy it to a server that supports streaming, secret storage, checkpointing, and job queues.
• Tool servers: Using MCP as the protocol, handling authentication with audit logs.
• Sandboxes: Let you write and execute code, with a secret proxy so credentials never enter the sandbox and the agent never sees them.
• LLM gateway: For reliability, with fallbacks and cost controls.

Managed Deep Agents: Two Layers in One

To make the building experience faster, LangChain has packaged all of the above into Managed Deep Agents — combining the harness layer and the managed infrastructure layer into one. In the past, you might have needed to define business logic, choose a harness, and then pick four or five different infrastructure components; now you only need to define your business logic, and everything else comes bundled together. This makes it incredibly easy to go from business logic to a production-grade, multi-tenant, scalable thing running on the web.

The talk highlighted three aspects of Managed Deep Agents, with fast building as the first emphasized:

• A lot of the work in multi-tenant agents goes not just into context engineering, but into how to securely connect to external things — tools, channels, and the authentication associated with them are critical, but also very tedious to set up.
• Channels refers to how an agent gets triggered: triggered in Slack? In Teams? Listening for new emails? Listening for new GitHub events? Managed Deep Agents handles all of this, providing out-of-the-box integrations while also handling authentication for those integrations.
• Deploying beyond your own computer is also very easy — it runs in the cloud.

Source: Interrupt London Keynote – LangChain (https://www.youtube.com/watch?v=XOUSuxY074U)