LangChain

LangChain builds open-source frameworks for AI agents. Deep Agents is its agent harness: an agent that plans, runs shell commands, and edits files in a sandbox you choose. BoxdSandbox makes that sandbox a boxd machine. It comes from boxd-langchain, a package the boxd team maintains, and LangChain lists it with its sandbox integrations (pull request). Deep Agents compiles to a LangGraph graph, so the same backend works from LangChain, LangGraph, and Deep Agents.

Set up

Install the package

pip install boxd-langchain langchain-anthropic

langchain-anthropic is for the example below; use your model provider’s package instead.

Create an API key

boxd auth keys create langchain --org <your-org>
export BOXD_API_KEY=bxd_...

Machines are created and billed in the key’s organization.

Give the agent a machine

from deepagents import create_deep_agent
from langchain_anthropic import ChatAnthropic

from boxd_langchain import BoxdSandbox

with BoxdSandbox.create(isolated=True, delete_after=3600) as backend:
    agent = create_deep_agent(
        model=ChatAnthropic(model="claude-sonnet-5-5"),
        system_prompt="You are a coding assistant with a Linux machine. Work in /home/boxd.",
        backend=backend,
    )
    result = agent.invoke(
        {"messages": [{"role": "user", "content": "Write hello.py that prints hello, run it and show me the output."}]}
    )
    print(result["messages"][-1].text)

Set ANTHROPIC_API_KEY for the model. The agent’s shell and file tools now run on the machine, and leaving the with block deletes it.

Come back to a machine

To keep the agent’s work, create the machine yourself and hand its id to BoxdSandbox. A backend made from an existing machine never deletes it.

from boxd import Boxd

from boxd_langchain import BoxdSandbox

client = Boxd()  # BOXD_API_KEY from the environment
machine = client.machines.create(isolated=True, labels={"app": "agent"})
client.machines.wait_until_ready(machine.id)

backend = BoxdSandbox(client=client, machine_id=machine.id)
backend.write("/home/boxd/notes.md", "# notes\n")

client.machines.hibernate(machine.id)

A hibernated machine keeps its disk and memory, and you stop paying for CPU and memory. Store the machine’s id. The next command wakes the machine, with its files as the agent left them:

backend = BoxdSandbox(client=client, machine_id=machine.id)
print(backend.execute("cat notes.md").output)

client.machines.delete(machine.id)

Fork a machine

A fork copies a machine into a new one, with its files and running processes as they are at that moment. Set a project up once, fork it, and give each agent its own copy:

from boxd_langchain import BoxdSandbox

with BoxdSandbox.create(isolated=True, delete_after=3600) as base:
    base.execute("git clone --depth 1 https://github.com/langchain-ai/deepagents")

    client = base.client
    fork = client.machines.fork(base.id, delete_after=3600)
    client.machines.wait_until_ready(fork.id)

    copy = BoxdSandbox(client=client, machine_id=fork.id)
    print(copy.execute("ls deepagents").output)

    client.machines.delete(fork.id)

The two machines change independently after the fork. backend.client is the plain boxd Python SDK client, so snapshots, egress allowlists, and everything else boxd offers are one call away. The package’s parallel_forks.py example runs two agents on two forks at once.

Deep Agents Code

The package also registers boxd as a sandbox for Deep Agents Code, LangChain’s terminal coding agent:

dcode install boxd-langchain --package
export BOXD_API_KEY=bxd_...
export BOXD_DELETE_AFTER=3600
dcode --sandbox boxd

Each session gets its own machine. dcode deletes it on a clean exit, and BOXD_DELETE_AFTER has boxd delete it after that many seconds if a run ends early. To pick a machine up again, pass its id or name, and dcode wakes it if it is asleep:

dcode --sandbox boxd --sandbox-id <machine>

What each machine gets

Isolation when you ask for it: isolated=True creates the machine with no boxd credentials and no route to your organization’s other machines. Use it whenever a model writes the code that runs.
A deadline: delete_after sets a delete-after timer, so boxd deletes the machine even if your process dies before the with block ends.
The default image: Ubuntu 24.04 with Python 3, git, Node.js, Docker, and ripgrep. For your own dependencies, start from a snapshot with BoxdSandbox.create(from_snapshot="my-snapshot").
Commands as the boxd user, who has passwordless sudo, in /home/boxd. A command’s output is its stdout and stderr, and its exit code comes back unchanged.
A timeout: a command that runs past its timeout, 30 minutes by default, is stopped with its whole process group and returns exit code 124.

boxd-langchain on GitHub: options, errors, limits, and three examples
boxd-langchain on PyPI
Sandbox integrations in LangChain’s docs
Sandboxes on boxd

Getting started

Guides

Integrations and automations

Use cases

References

Set up

Come back to a machine

Fork a machine

Deep Agents Code

What each machine gets

Read more