Interpreter Skills: Building Workflows for Agents

Building workflows for agents with Skills and Interpreters

Hunter Lovell
May 29, 2026

13
min

Key Takeaways

Skills can now direct the harness, not just the model. Because interpreter code can talk to the agent loop directly, a skill can spawn subagents, manage a task graph, and handle partial failures as one reviewed workflow
Skills can now become both a set of instructions and an API. A normal skill tells the agent how to do a task and hopes it follows along. An interpreter skill ships a module, so the deterministic part lives in code that can be reviewed and iterated on, while the model decides when to call it and what inputs to pass
Agent work can now be more easily evaluated. Instead of asking "did the agent generally follow instructions?", you can ask more concrete questions like "did it call the expected function?"

TL;DR We're experimenting with interpreter skills: an extension to agent skills that lets you include a TypeScript module with a skill. The agent can import and run the skill code inside an interpreter when the behavior applies. Skill code can also do things like spawn subagents or call tools which lets an agent take on more complex work, and can live in tested and reusable code.

We recently introduced interpreters to Deep Agents: a small embedded TypeScript runtime where agents can write and execute code as part of the harness. Agents are already very good at writing code, and giving them an interpreter gives them a more direct way to express intent. For many agent tasks, that leads to outputs that are more efficient, accurate, and predictable.

---
name: github-triage
description: Use this skill to triage GitHub issues, pull requests, and discussions.
metadata:
  module: ./index.ts
---

Use this skill when a user asks for repository triage.

Import the module using the interpreter and call `triage(repo, options)`.

Usage:

```ts
const { triage } = await import("@/skills/github-triage");

const result = await triage("langchain-ai/deepagents", {
issues: true,
prs: true,
});

result.toMarkdown();


`SKILL.md` is how the agent discovers the behavior. `index.ts` is what the interpreter can execute. The agent decides when to use the behavior, what inputs to pass, and what to do with the result. The interpreter handles the actual execution of code.

## Remind me what skills are again?

Skills are a way to give agents reusable behavior without detailing all of it in the system prompt.

A skill is usually a directory with a `SKILL.md` file. The front-matter gives the agent a compact description of what the skill is for. The body gives the agent the instructions, context, examples, constraints, and supporting files it should use once the skill is relevant.

What makes skills work is a mechanism called "progressive disclosure". The agent does not need every skill in context all the time. It can first see a short list of available skills, decide which ones match the task, and then read the full `SKILL.md` only when needed.

## What's an interpreter?

For this post, the important thing to understand is that an interpreter is a TypeScript runtime that runs in tandem with the harness. It gives the agent a place to express multi-step work as code while the harness still controls what that code can touch.

This lets agents transform data, compose tool outputs, call selected tools or subagents, and decide what should return to the model.

Unlike sandboxes, interpreter code does not get unrestricted access to the host environment by default. Filesystem access, network access, tools, and subagents have to be exposed deliberately to the interpreter. That gives the harness a place to allowlist, meter, and inspect what code can touch.

## What's an interpreter skill?

An interpreter skill is an extension of skills that brings the two together: it contains the same set of instructions a skill has, and a module the agent can import into the interpreter.

The basic shape is the same one from the opening example. `SKILL.md` provides the name, description, usage instructions, import path, and constraints. `index.ts` exports the helpers or workflows that define the behavior in code:

```typescript
// skills/table-cleanup/index.ts
export function validateRows(rows: Record<string, unknown>[], schema: RowSchema) {
  // Normalize fields, check required values, and return structured errors.
  // (this is code you would write as part of the skill)
}

When the skill applies, the agent can import the module and call it:

const { validateRows } = await import("@/skills/table-cleanup");

const errors = validateRows(rows, invoiceSchema);

This changes what a skill can guarantee:

A normal skill says: here are instructions for how to do this task. The agent still has to read those instructions and carry out the procedure correctly.
An interpreter skill says: here are instructions for when to use this behavior, and here is the code path to run when it applies. The deterministic part can live in code instead of as loose instructions in context.

The model decides whether the skill applies, which inputs to pass, how to use the output, and what to do next. The module defines how procedures should actually be ran.

Using skills to work with agent state

Filesystem agents made it clear that agents work better when they have somewhere to put intermediate state (a form of memory). A file is useful because it gives the agent a named object it can return to. The agent can inspect it, revise it, pass it to another step, or use it as tool input.

Interpreters let the agent represent that state in a more pliable form, and skills can teach the agent how to interact with it:

The module exposes task-specific operations for those values.
The agent writes code to combine those operations.
The skill author owns the behavior of each operation.

Imagine a skill for interacting with csv files. SKILL.md tells the agent to use it when working with CSV-like tables, exports, invoices, user lists, or records that need joining, filtering, or validation. index.ts exports a small table API:

export {
  parseCsv,
  joinTables,
  filterRows,
  validateRows,
  groupBy,
  summarize,
  toCsv,
};

The agent can then compose those operations in interpreter code:

const invoices = parseCsv(await tools.readFile({ path: "/invoices.csv" }));
const customers = parseCsv(await tools.readFile({ path: "/customers.csv" }));

const joined = joinTables(invoices, customers, "customer_id");
const invalid = validateRows(joined, invoiceSchema);
const byRegion = groupBy(joined, "region");

summarize(byRegion, ["total_due", "late_count"]);

The agent controls which values to pass and what to do with the result. The skill author controls what "join", "validate", and "summarize" mean.