LangChain’s new DeepAgents framework and Runloop’s agent execution platform address two sides of the same emerging problem. DeepAgents formalize how agents should reason, plan, and delegate. Runloop provides the execution environment AI agents need as they move beyond prototypes.

The bigger signal in this partnership is not a single feature or integration. It’s that agentic AI is crossing a threshold. Agents are no longer being treated as prompt wrappers or chatbots. They are being treated as long-running systems that write code, invoke tools, manage state, and serve real users. That shift forces agent frameworks and infrastructure to evolve together.

LangChain DeepAgents represents a meaningful step forward in agent frameworks. It formalizes how agents plan, delegate, and reason in ways that align with real software systems. Runloop complements that work by providing the execution environment AI agents need when they move beyond the notebook or local terminal.

The demo shows the practical outcome of developing these layers in tandem:

• Agent behavior remains consistent from prototype to production
• Infrastructure supports long-running, stateful workflows
• Operational concerns are built in rather than added later

This partnership reflects where the industry is going. As agents become more capable, execution, state, and observability become first-order concerns. LangChain and Runloop are addressing those concerns from opposite sides of the stack—and the demo shows how cleanly they fit together.

The Demo, Step by Step

Step 1: Building a Custom Agent with LangChain DeepAgents

The demo starts with a fork of the LangChain DeepAgents repository. The presenters customize the agent in straightforward ways: editing the prompt, adjusting behavior, and adding new tools focused on dependency upgrades for Python and TypeScript.

What matters here is not the specific use case, but the behavior the framework enables:

• The agent plans before acting
• It invokes tools deliberately
• It reasons over a real codebase
• It produces structured recommendations

This is DeepAgents doing what it was designed to do: supporting multi-step, stateful reasoning instead of single-prompt interactions.

The demo then shows two development workflows supported by LangChain:

• A CLI-based workflow for fast iteration
• A LangGraph Server workflow paired with LangChain’s open-source Chat UI for inspecting tool calls and agent behavior

LangChain’s strength here is flexibility. DeepAgents fits into real developer workflows rather than forcing a single interface or execution model.

Step 2: Running and Inspecting the Agent Locally

The agent is run locally against its own repository. It scans dependencies, identifies outdated packages, flags higher-risk upgrades, and proposes a plan. The presenters show both Python and TypeScript outputs, highlighting that the agent is performing precisely the kind of work it was designed for.

This phase reinforces a vital point: prototyping agents is now relatively easy. DeepAgents lowers the barrier to building agents that reason and use tools in a disciplined way.

The more challenging part comes next.
‍

Step 3: Moving from Local Prototype to Cloud Execution

After the agent works locally, the demo addresses the core problem most teams encounter: sharing, deploying, and scaling the agent.
‍
This is where Runloop enters. The presenters introduce Runloop’s execution primitives:

• DevBoxes as the core unit of execution
• Snapshots to capture full environment state
• Blueprints to create reproducible templates‍
• Object and secret stores for centralized key and data management

These primitives matter because DeepAgents implicitly assume:

• A real filesystem
• Persistent state
• Safe execution of model-generated code
• Repeatable environments

Runloop provides those capabilities without requiring teams to build custom infrastructure.
‍

Step 4: Deploying the DeepAgent to Runloop

Using Runloop’s GitHub Action, the presenters deploy their DeepAgent by reference. The action registers the agent’s repository and branch without packaging or containerization. Dependencies are installed only when the agent is mounted onto a DevBox.
‍
They then:

• Create a Devbox with the AI agent attached
• Mount a code repository for the agent to operate on
• Inject secrets securely
• Launch the Devbox
• Run the agent remotely using the same commands used locally

The agent logic does not change. Only the execution environment does. This continuity is one of the key benefits of the LangChain–Runloop pairing.

Step 5: Using Snapshots to Accelerate Iteration

Once the agent is running successfully, the demo snapshots the Devbox. New Devboxes launched from that snapshot start significantly faster because dependencies and environment state are already present.

For DeepAgents, this is foundational. Planning, reflection, and evaluation all benefit from:

• Fast environment startup
• Deterministic resets
• Reusable state

Snapshots turn agent experiments into repeatable systems.
‍

Step 6: Deploying a User-Facing Application

The demo then moves up the stack to a Next.js application built on top of the agent. End users interact with a UI, submit repository URLs, and receive responses powered by DeepAgents running inside Runloop Devboxes.

Updating the application is as simple as pointing it to a new snapshot ID. The app redeploys, and users immediately interact with the updated agent environment.

At this point, the architecture is clear:

• LangChain defines agent reasoning and tool orchestration
• Runloop provides execution, isolation, and scaling
  ‍

Step 7: Operating the Agent in Production

The final portion of the demo focuses on operations. In the Runloop dashboard, we show:

• Logs and error visibility
• Running and completed Devboxes
• Correlation between user sessions and execution state
• Inspection of agent outputs and tool calls

This is the layer often missing from agent demos. Here, it is explicit. Agents are observable, debuggable, and manageable—requirements for enterprise use.