Flue — The Sandbox Agent Framework

The Universal Agent

A Sandbox Agent is the most powerful form of AI agent. The pattern pairs an agent harness (like Claude Code or pi) with a dedicated workspace for the agent that includes an isolated filesystem, bash, and all of the agent context required to complete its task.

We believe every agent should have a sandbox. Historically, the sandbox pattern was too slow and expensive to use in most situations. But recent advances in microVMs and in-process virtualization have made sandboxes fast and cheap enough to run everywhere — even in high-traffic scenarios like customer support and search. It's time to embrace the shift.

Flue is the agent framework designed for sandbox agents. Prompt the LLM, call skills, navigate the file tree, delegate tasks, and run bash commands — all inside a secure virtualized sandbox or proper container that you control.

When you're ready to ship, Flue builds and bundles your agents into an HTTP server bundle that you can deploy anywhere. Or, skip the build and run your agents locally, perfect for automating CI workflows.

The Sandbox Agent

04 / Filesystem read · write · grep · glob

03 / Context skills · roles · AGENTS.md

02 / Sandbox bash · security · network

01 / Harness intelligence · tools · memory

Build your own customer support agent in 11 lines of TypeScript.

Replaces

Intercom AIZendesk AIAda

Stop renting someone else's agent. Off-the-shelf AI tools are built for a general audience and struggle to fit to your product, your data, your customers, or your exact workflows.

Flue gives you the building blocks to build smarter agents with an intuitive, programmable interface. You own the entire stack: the agent, the harness, and the sandbox itself. Connect it all together and start building a more powerful, autonomous agent.

// Built for: Cloudflare
import { getVirtualSandbox } from '@flue/sdk/cloudflare';
import type { FlueContext } from '@flue/sdk/client';

// POST /agents/support/:id
export const triggers = { webhook: true };

export default async function ({ init, payload, env }: FlueContext) {
  // Mount a bucket as your agent's filesystem in a virtual sandbox.
  // The agent can grep, glob, and read from the knowledge base with 
  // bash, without the need of a traditional, expensive container.
  const sandbox = await getVirtualSandbox(env.KNOWLEDGE_BASE);
  const session = await init({ sandbox });
  // Prompt! The agent harness includes your workspace AGENTS.md,
  // skills, and roles (aka subagents) to complete your task as 
  // desired. Use `session.skill()` to call a skill directly.
  return await session.prompt(
    `Respond to this customer message: ${payload.message}`,
    { role: 'support-agent' },
  );
}

// Built for: Node, GitHub Actions
import type { FlueContext } from '@flue/sdk/client';
import { Octokit } from '@octokit/core';
import * as v from 'valibot';

// Triggered in CI via the CLI — no HTTP endpoint needed.
export const triggers = {};

export default async function ({ init, payload, env }: FlueContext) {
  const session = await init();
  // Run the 'triage' skill to triage the GitHub issue.
  const triage = await session.skill('triage', {
    args: { issueNumber: payload.issueNumber },
    result: v.object({
      severity: v.picklist(['low', 'medium', 'high', 'critical']),
      reproducible: v.boolean(),
      summary: v.string(),
    }),
  });
  // Post the triage result back to GitHub.
  // The agent/sandbox never sees your sensitive GITHUB_TOKEN.
  const octokit = new Octokit({ auth: env.GITHUB_TOKEN });
  await octokit.request('POST /repos/{owner}/{repo}/issues/{num}/comments', {
    owner: 'withastro',
    repo: 'flue',
    num: payload.issueNumber,
    body: `**Severity:** ${triage.severity}\n**Reproducible:** ${triage.reproducible}\n\n${triage.summary}`,
  });
}

// Built for: Node, Daytona
import type { FlueContext } from '@flue/sdk/client';
import { Daytona } from '@daytona/sdk';
import { daytona } from '@flue/connectors/daytona';

// POST /agents/code/:id
export const triggers = { webhook: true };

export default async function ({ init, payload, env }: FlueContext) {
  // Each session gets a real container via Daytona.
  const client = new Daytona({ apiKey: env.DAYTONA_API_KEY });
  const sandbox = await client.create();
  const session = await init({ sandbox: daytona(sandbox) });
  // Setup the sandbox (for illustrative purposes only). 
  // In production, you'd want to bake setup into the container image,
  // or use a snapshot (if available from your sandbox provider).
  await session.shell(`git clone ${payload.repo} /workspace/project`);
  await session.shell('npm install', { cwd: '/workspace/project' });
  return await session.prompt(payload.prompt);
}

// Built for: Node
import type { FlueContext } from '@flue/sdk/client';
import { getVirtualSandbox } from '@flue/sdk/node';
import * as v from 'valibot';

// POST /agents/data/:id
export const triggers = { webhook: true };

export default async function ({ init, payload }: FlueContext) {
  // Mount the data analyst context to the agent session — this contains
  // all the files (context) & skills (abilities) needed for the agent to
  // complete its task. The agent can run `ls`, `grep`, write Python, 
  // and make read-only queries to fetch data from your analytics service.
  const session = await init({ sandbox: await getVirtualSandbox('./data') });
  // Prompt! The agent harness includes your workspace AGENTS.md,
  // skills, and roles (aka subagents) to analyze the data and
  // complete your task as desired.
  return await session.prompt(
    `Answer this user question: ${payload.message}`,
    { role: 'data-analyst' },
  );
}

Deploy Anywhere

Node.js