Run agents with agent-runtime

pnpm add @tangle-network/agent-runtime @tangle-network/agent-interface @tangle-network/agent-provider-tangle @tangle-network/sandbox

import { Sandbox } from "@tangle-network/sandbox";
import { createTangleProvider } from "@tangle-network/agent-provider-tangle";
import { providerAsSandboxClient, runAgentRounds } from "@tangle-network/agent-runtime/kernel";
import type { AgentProfile } from "@tangle-network/agent-interface";
 
// 1. Connect to Tangle Sandbox
const sandbox = new Sandbox({
  apiKey: process.env.TANGLE_API_KEY!,
  baseUrl: "https://sandbox.tangle.tools",
});
 
// 2. Wrap the sandbox as an environment provider
const provider = createTangleProvider({ client: sandbox });
 
// 3. Adapt the provider into the runtime's sandbox client
const client = providerAsSandboxClient(provider);
 
// 4. Define the agent you want to run
const profile = {
  name: "my-claude-agent",
  harness: "claude-code",       // or "codex", "opencode", "kimi-code", "pi"
  model: { provider: "anthropic", default: "anthropic/claude-sonnet-4-6" },
} satisfies AgentProfile;
 
// 5. Run it
const result = await runAgentRounds({
  task: "Review the last 5 commits and summarize the changes.",
  driver: {
    plan: async (task, history) => (history.length === 0 ? [task] : []),
    decide: () => "done" as const,
  },
  agentRun: { profile, taskToPrompt: (t) => t },
  output: { parse: (events) => events },
  ctx: { sandboxClient: client },
});
 
console.log(`decision: ${result.decision} — ${result.iterations.length} iteration(s)`);

import {
  createSupervisor,
  definePersona,
  fanout,
  runPersonified,
  type Agent,
  type Scope,
} from "@tangle-network/agent-runtime/kernel";
 
// A driver that spawns two children, drains them, picks the best
const driver: Agent<string, unknown> = {
  name: "two-arm-driver",
  act: async (task: string, scope: Scope<unknown>) => {
    // Each spawn RESERVES its whole ceiling from the shared pool atomically
    const [arm1, arm2] = await Promise.all([
      scope.spawn({ task: `${task} (arm A)`, ceiling: { usd: 0.50 } }),
      scope.spawn({ task: `${task} (arm B)`, ceiling: { usd: 0.50 } }),
    ]);
 
    // Drain both, then select the best valid settlement
    const results = await Promise.all([arm1.result, arm2.result]);
    return results.find((r) => r.ok) ?? results[0];
  },
};
 
const persona = definePersona({
  agent: driver,
  profile: { harness: "claude-code", model: { provider: "anthropic", default: "anthropic/claude-sonnet-4-6" } },
});
 
// Run under a supervisor with a budget ceiling
const outcome = await runPersonified({
  persona,
  task: "Review this PR from two angles: correctness and style.",
  budget: { usd: 1.00 },
  ctx: { sandboxClient: client },
});

import { promptHandle, runGraph } from "@tangle-network/agent-runtime/kernel";
 
const plan = promptHandle("Review the failing tests and propose a fix.");
const implement = promptHandle("Implement the fix you proposed.");
const review = promptHandle("Review the implementation. Approve or request changes.");
 
const graph = {
  nodes: { plan, implement, review },
  edges: [
    { from: "plan", to: "implement" },
    { from: "implement", to: "review" },
    // review can loop back to implement if changes are requested
  ],
};
 
for await (const event of runGraph(graph, { sandboxClient: client })) {
  if (event.type === "node_complete") {
    console.log(`${event.node}: ${event.outcome.type}`);
  }
}