Interpreters

​

Why use interpreters?

​

Choose a pattern

​

Quickstart

pip install -U "deepagents[quickjs]"

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="google_genai:gemini-3.5-flash",
    middleware=[CodeInterpreterMiddleware()],
)

​

How interpreters work

const rows = [
  { team: "alpha", score: 8 },
  { team: "beta", score: 13 },
  { team: "alpha", score: 21 },
];

const totals = rows.reduce((acc, row) => {
  acc[row.team] = (acc[row.team] ?? 0) + row.score;
  console.log(`${row.team} score: ${acc[row.team]}`);
  return acc;
}, {});

totals;

• Tools, through programmatic tool calling (PTC). Provide an allowlist of tools as async functions under the tools namespace. These can be the agent’s own tools or standalone tools you define and pass in.
• Subagents, through dynamic subagents. When the agent has subagents configured, the interpreter exposes a task() global for dispatching them from code.

​

Programmatic tool calling (PTC)

const result: string = await tools.webSearch({
  query: "deepagents interpreters",
});

​

Enable PTC

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="google_genai:gemini-3.5-flash",
    middleware=[CodeInterpreterMiddleware(ptc=["web_search"])],
)

const topics = ["retrieval", "memory", "evaluation"];

const results = await Promise.all(
  topics.map((topic) =>
    tools.webSearch({ query: `${topic} best practices 2025` }),
  ),
);

results.join("\n\n");

​

Dynamic subagents

• Fan-out and synthesize: Run the same kind of work across many items in parallel, then combine the results.
• Verification: Send findings to independent verifier subagents and keep only confirmed results.
• Recursive workflows: Keep a working set in interpreter variables, select slices, call subagents, and refine the result.

const paths = ["src/auth.ts", "src/routes/api.ts"];

const reviews = await Promise.all(
  paths.map((path) =>
    task({
      description: `Review ${path} for authentication issues`,
      subagentType: "reviewer",
    }),
  ),
);

reviews.join("\n\n");

​

Persistence

• "thread" (default): State persists across eval calls and across agent turns. The middleware snapshots interpreter state after each agent turn and restores it before the next turn.
• "turn": State persists across multiple eval calls within one agent turn, then resets on the next turn.
• "call": Each eval call runs in a fresh REPL with no carry-over from prior calls.

1. A turn starts, and the middleware restores the latest interpreter snapshot for the thread.
2. The agent calls eval one or more times. Those calls share one live context; the middleware does not snapshot between them.
3. The turn finishes, and the middleware writes an updated snapshot to graph state.
4. The next turn resumes from that snapshot instead of an empty runtime.

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="google_genai:gemini-3.5-flash",
    middleware=[
        CodeInterpreterMiddleware(
            mode="thread",  # Default
        )
    ],
)

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware
from langgraph.checkpoint.memory import MemorySaver

agent = create_deep_agent(
    model="google_genai:gemini-3.5-flash",
    checkpointer=MemorySaver(),
    middleware=[CodeInterpreterMiddleware(mode="thread")],
)

​

Security

​

Configuration