Pi

Image updates

Ready-made agent images are updated every morning to include the current CLI version. To use a fixed image version, pin a template version.

Pi is an extensible AI agent with a choice of models and providers. Its core tools read, write, and edit files and run commands. Skills and extensions add other capabilities. Use the ready-made pi template in AgentBox.

Connect

Install the AgentBox SDK and set AGENTBOX_API_KEY. This example uses OpenRouter: it reads OPENROUTER_API_KEY, selects the provider with --provider openrouter, and the model with --model qwen/qwen3-coder-next. Unlike the OpenCode command, this command passes the provider in a separate flag.

Pi supports other providers too. When switching, match --provider, --model, and the key variable: for example, ANTHROPIC_API_KEY for Anthropic or OPENAI_API_KEY for OpenAI. See the Pi provider documentation for the full list.

To access the model, you can use the AgentBox HTTPS proxy at https://sandbox-proxy.agentbox.ru:65181.

The examples pass HTTPS_PROXY, HTTP_PROXY, and NO_PROXY only to the agent command and its child processes. These are process-wide network settings: other agent requests may also use the proxy. NO_PROXY keeps connections to localhost and 127.0.0.1 direct.

Extract meeting actions

The example uploads meeting notes and asks Pi to extract agreed actions, owners, and deadlines into actions.md. An action without an agreed deadline should be marked accordingly. Discussion without a decision goes in a separate section. Replace the input with your own meeting transcript.

mjs

import { Sandbox } from "@abox-dev/sdk";

const apiKey = process.env.OPENROUTER_API_KEY;
if (!apiKey) throw new Error("OPENROUTER_API_KEY is required");
const proxy =
  process.env.SANDBOX_PROXY_URL ?? "https://sandbox-proxy.agentbox.ru:65181";
const sandbox = await Sandbox.create("pi", { timeoutMs: 600_000 });
try {
  await sandbox.files.makeDir("/home/user/work");
  await sandbox.files.write(
    "/home/user/work/meeting.md",
    "Meeting: 2026-09-18\nOlga will send a revised quote to Acme by 2026-09-21.\nPavel will check stock for the next delivery; no deadline was agreed.\nThe marketing budget was discussed but no decision was made.\n",
  );
  const handle = await sandbox.commands.run(
    "pi --provider openrouter --model qwen/qwen3-coder-next --no-session -p",
    {
      cwd: "/home/user/work",
      timeoutMs: 300_000,
      background: true,
      stdin: true,
      envs: {
        OPENROUTER_API_KEY: apiKey,
        HTTPS_PROXY: proxy,
        HTTP_PROXY: proxy,
        NO_PROXY: "localhost,127.0.0.1",
      },
      onStderr: (chunk) => process.stderr.write(chunk),
    },
  );
  await handle.sendStdin(
    "Read meeting.md and write actions.md: agreed actions, owners, and deadlines. Mark missing deadlines as not agreed. Keep discussion without a decision separate.",
  );
  await handle.closeStdin();
  const result = await handle.wait();
  console.log(result.stdout);
  console.log(
    "actions.md\n" + (await sandbox.files.read("/home/user/work/actions.md")),
  );
} finally {
  await sandbox.kill();
}

import os
import sys
from agentbox import Sandbox

api_key = os.environ["OPENROUTER_API_KEY"]
proxy = os.getenv("SANDBOX_PROXY_URL", "https://sandbox-proxy.agentbox.ru:65181")
sandbox = Sandbox.create("pi", timeout=600)
try:
    sandbox.files.make_dir("/home/user/work")
    sandbox.files.write(
        "/home/user/work/meeting.md",
        "Meeting: 2026-09-18\nOlga will send a revised quote to Acme by 2026-09-21.\nPavel will check stock for the next delivery; no deadline was agreed.\nThe marketing budget was discussed but no decision was made.\n",
    )
    handle = sandbox.commands.run(
        "pi --provider openrouter --model qwen/qwen3-coder-next --no-session -p",
        cwd="/home/user/work",
        timeout=300,
        background=True,
        stdin=True,
        envs={
            "OPENROUTER_API_KEY": api_key,
            "HTTPS_PROXY": proxy,
            "HTTP_PROXY": proxy,
            "NO_PROXY": "localhost,127.0.0.1",
        },
    )
    handle.send_stdin(
        "Read meeting.md and write actions.md: agreed actions, owners, and deadlines. Mark missing deadlines as not agreed. Keep discussion without a decision separate."
    )
    handle.close_stdin()
    result = handle.wait(on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr))
    print(result.stdout)
    print("actions.md\n" + sandbox.files.read("/home/user/work/actions.md"))
finally:
    sandbox.kill()

package main

import (
	"context"
	"errors"
	"fmt"
	"github.com/abox-dev/sdk/packages/go-sdk"
	"log"
	"os"
	"time"
)

func run() (err error) {
	apiKey, proxy := os.Getenv("OPENROUTER_API_KEY"), os.Getenv("SANDBOX_PROXY_URL")
	if apiKey == "" {
		return errors.New("OPENROUTER_API_KEY is required")
	}
	if proxy == "" {
		proxy = "https://sandbox-proxy.agentbox.ru:65181"
	}
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
	defer cancel()
	client, err := agentbox.NewClient()
	if err != nil {
		return err
	}
	sandbox, err := client.Sandboxes.Create(ctx, &agentbox.CreateSandboxOptions{Template: "pi", Timeout: 10 * time.Minute})
	if err != nil {
		return err
	}
	defer func() {
		cleanupCtx, stop := context.WithTimeout(context.Background(), 30*time.Second)
		defer stop()
		_, cleanupErr := sandbox.Kill(cleanupCtx)
		err = errors.Join(err, cleanupErr)
	}()
	if _, err := sandbox.Files.MakeDir(ctx, "/home/user/work"); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/meeting.md", "Meeting: 2026-09-18\nOlga will send a revised quote to Acme by 2026-09-21.\nPavel will check stock for the next delivery; no deadline was agreed.\nThe marketing budget was discussed but no decision was made.\n", nil); err != nil {
		return err
	}
	handle, err := sandbox.Commands.Start(ctx, "sh", &agentbox.CommandOptions{
		Args: []string{"-lc", "pi --provider openrouter --model qwen/qwen3-coder-next --no-session -p"}, Cwd: "/home/user/work", Stdin: true,
		Env:      map[string]string{"OPENROUTER_API_KEY": apiKey, "HTTPS_PROXY": proxy, "HTTP_PROXY": proxy, "NO_PROXY": "localhost,127.0.0.1"},
		OnStderr: func(chunk []byte) { fmt.Fprint(os.Stderr, string(chunk)) },
	})
	if err != nil {
		return err
	}
	if _, err := handle.Write(ctx, []byte("Read meeting.md and write actions.md: agreed actions, owners, and deadlines. Mark missing deadlines as not agreed. Keep discussion without a decision separate.")); err != nil {
		return err
	}
	if err := handle.CloseStdin(ctx); err != nil {
		return err
	}
	result, err := handle.Wait(ctx)
	if err != nil {
		return err
	}
	fmt.Println(string(result.Stdout))
	report, err := sandbox.Files.ReadText(ctx, "/home/user/work/actions.md", "")
	if err != nil {
		return err
	}
	fmt.Println("actions.md\n" + report)
	return nil
}
func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

-p prints the final response and exits. The task is sent through stdin. Closing the input stream tells the agent that the complete text has arrived. Pi uses its default tools for reading, writing, editing files, and running commands through bash. The example adds no tool restrictions. The AgentBox sandbox provides isolation. --no-session disables history persistence without preventing the agent from writing its output file.

The application reads actions.md before stopping the sandbox. Command or file errors propagate to the caller, and finally deletes the sandbox.

Events and follow-up questions

This example starts Pi with --mode rpc: the application sends JSON commands to stdin and reads events from stdout. The agent first prepares the meeting actions, then receives an updated deadline and edits the same file while keeping the conversation context.

mjs

import { Readable } from "node:stream";
import { Sandbox } from "@abox-dev/sdk";

const apiKey = process.env.OPENROUTER_API_KEY;
if (!apiKey) throw new Error("OPENROUTER_API_KEY is required");
const proxy =
  process.env.SANDBOX_PROXY_URL ?? "https://sandbox-proxy.agentbox.ru:65181";
const sandbox = await Sandbox.create("pi", { timeoutMs: 600_000 });
try {
  await sandbox.files.write(
    "/home/user/meeting.md",
    "Olga will send a revised quote to Acme by 2026-09-21. Pavel will check stock; no deadline was agreed.\n",
  );
  const messages = new Readable({ objectMode: true, read() {} });
  let buffer = "";
  const agent = await sandbox.commands.run(
    "pi --mode rpc --provider openrouter --model qwen/qwen3-coder-next",
    {
      cwd: "/home/user",
      background: true,
      stdin: true,
      timeoutMs: 300_000,
      envs: {
        OPENROUTER_API_KEY: apiKey,
        HTTPS_PROXY: proxy,
        HTTP_PROXY: proxy,
        NO_PROXY: "localhost,127.0.0.1",
      },
      onStdout(chunk) {
        buffer += chunk;
        let end;
        while ((end = buffer.indexOf("\n")) !== -1) {
          const line = buffer.slice(0, end);
          buffer = buffer.slice(end + 1);
          try {
            if (line.trim()) messages.push(JSON.parse(line));
          } catch (error) {
            messages.destroy(error);
          }
        }
      },
      onStderr: (chunk) => process.stderr.write(chunk),
    },
  );
  agent.wait().then(
    () => messages.push(null),
    (error) => messages.destroy(error),
  );
  const incoming = messages[Symbol.asyncIterator]();
  let nextId = 0;
  async function prompt(text) {
    const id = String(++nextId);
    await agent.sendStdin(
      JSON.stringify({ id, type: "prompt", message: text }) + "\n",
    );
    let accepted = false,
      settled = false,
      lastAssistant;
    while (!accepted || !settled) {
      const { value: event, done } = await incoming.next();
      if (done) throw new Error("Pi closed before completing the task");
      if (event.type === "response" && event.id === id) {
        if (!event.success) throw new Error(event.error);
        accepted = true;
      }
      if (
        event.type === "message_update" &&
        event.assistantMessageEvent.type === "text_delta"
      ) {
        process.stdout.write(event.assistantMessageEvent.delta);
      }
      if (event.type === "message_end" && event.message.role === "assistant")
        lastAssistant = event.message;
      if (event.type === "agent_settled") settled = true;
    }
    if (
      !lastAssistant ||
      ["error", "aborted"].includes(lastAssistant.stopReason)
    ) {
      throw new Error(
        lastAssistant?.errorMessage ?? "Pi did not complete the response",
      );
    }
    console.log();
  }
  await prompt(
    "Read meeting.md and write actions.md with actions, owners and deadlines. Mark unagreed deadlines explicitly.",
  );
  await prompt(
    "Pavel has now confirmed a deadline of 2026-09-22. Update his action in actions.md; keep the other action unchanged.",
  );
  console.log(
    "actions.md\n" + (await sandbox.files.read("/home/user/actions.md")),
  );
} finally {
  await sandbox.kill();
}

import json
import os
import sys
from queue import Queue
from threading import Thread
from agentbox import Sandbox

api_key = os.environ["OPENROUTER_API_KEY"]
proxy = os.getenv("SANDBOX_PROXY_URL", "https://sandbox-proxy.agentbox.ru:65181")
sandbox = Sandbox.create("pi", timeout=600)
try:
    sandbox.files.write(
        "/home/user/meeting.md",
        "Olga will send a revised quote to Acme by 2026-09-21. Pavel will check stock; no deadline was agreed.\n",
    )
    messages = Queue()
    buffer = ""

    def on_stdout(chunk):
        global buffer
        buffer += chunk
        while "\n" in buffer:
            line, buffer = buffer.split("\n", 1)
            if line.strip():
                messages.put(json.loads(line))

    agent = sandbox.commands.run(
        "pi --mode rpc --provider openrouter --model qwen/qwen3-coder-next",
        cwd="/home/user",
        background=True,
        stdin=True,
        timeout=300,
        envs={
            "OPENROUTER_API_KEY": api_key,
            "HTTPS_PROXY": proxy,
            "HTTP_PROXY": proxy,
            "NO_PROXY": "localhost,127.0.0.1",
        },
    )

    def read_messages():
        try:
            agent.wait(
                on_stdout=on_stdout,
                on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr),
            )
            messages.put(RuntimeError("Pi closed before completing the task"))
        except Exception as error:
            messages.put(error)

    reader = Thread(target=read_messages, daemon=True)
    reader.start()
    next_id = 0

    def prompt(text):
        global next_id
        next_id += 1
        request_id = str(next_id)
        agent.send_stdin(
            json.dumps({"id": request_id, "type": "prompt", "message": text}) + "\n"
        )
        accepted = settled = False
        last_assistant = None
        while not accepted or not settled:
            event = messages.get(timeout=300)
            if isinstance(event, Exception):
                raise event
            if event["type"] == "response" and event.get("id") == request_id:
                if not event["success"]:
                    raise RuntimeError(event["error"])
                accepted = True
            if (
                event["type"] == "message_update"
                and event["assistantMessageEvent"]["type"] == "text_delta"
            ):
                print(event["assistantMessageEvent"]["delta"], end="", flush=True)
            if (
                event["type"] == "message_end"
                and event["message"]["role"] == "assistant"
            ):
                last_assistant = event["message"]
            if event["type"] == "agent_settled":
                settled = True
        if last_assistant is None or last_assistant["stopReason"] in (
            "error",
            "aborted",
        ):
            raise RuntimeError(
                (last_assistant or {}).get(
                    "errorMessage", "Pi did not complete the response"
                )
            )
        print()

    prompt(
        "Read meeting.md and write actions.md with actions, owners and deadlines. Mark unagreed deadlines explicitly."
    )
    prompt(
        "Pavel has now confirmed a deadline of 2026-09-22. Update his action in actions.md; keep the other action unchanged."
    )
    print("actions.md\n" + sandbox.files.read("/home/user/actions.md"))
finally:
    sandbox.kill()

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/abox-dev/sdk/packages/go-sdk"
	"log"
	"os"
	"strconv"
	"strings"
	"time"
)

type assistantMessage struct {
	Role         string `json:"role"`
	StopReason   string `json:"stopReason"`
	ErrorMessage string `json:"errorMessage"`
}
type event struct {
	ID                    string           `json:"id"`
	Type                  string           `json:"type"`
	Success               bool             `json:"success"`
	Error                 string           `json:"error"`
	Message               assistantMessage `json:"message"`
	AssistantMessageEvent struct {
		Type  string `json:"type"`
		Delta string `json:"delta"`
	} `json:"assistantMessageEvent"`
}

func run() (err error) {
	apiKey, proxy := os.Getenv("OPENROUTER_API_KEY"), os.Getenv("SANDBOX_PROXY_URL")
	if apiKey == "" {
		return errors.New("OPENROUTER_API_KEY is required")
	}
	if proxy == "" {
		proxy = "https://sandbox-proxy.agentbox.ru:65181"
	}
	ctx, cancel := context.WithTimeout(context.Background(), 8*time.Minute)
	defer cancel()
	client, err := agentbox.NewClient()
	if err != nil {
		return err
	}
	sandbox, err := client.Sandboxes.Create(ctx, &agentbox.CreateSandboxOptions{Template: "pi", Timeout: 10 * time.Minute})
	if err != nil {
		return err
	}
	defer func() {
		cleanupCtx, stop := context.WithTimeout(context.Background(), 30*time.Second)
		defer stop()
		_, cleanupErr := sandbox.Kill(cleanupCtx)
		err = errors.Join(err, cleanupErr)
	}()
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/meeting.md", "Olga will send a revised quote to Acme by 2026-09-21. Pavel will check stock; no deadline was agreed.\n", nil); err != nil {
		return err
	}
	messages := make(chan event, 64)
	parseErrors := make(chan error, 1)
	var buffer string
	agent, err := sandbox.Commands.Start(ctx, "pi", &agentbox.CommandOptions{
		Args: []string{"--mode", "rpc", "--provider", "openrouter", "--model", "qwen/qwen3-coder-next"},
		Cwd:  "/home/user", Stdin: true,
		Env: map[string]string{"OPENROUTER_API_KEY": apiKey, "HTTPS_PROXY": proxy, "HTTP_PROXY": proxy, "NO_PROXY": "localhost,127.0.0.1"},
		OnStdout: func(chunk []byte) {
			buffer += string(chunk)
			for {
				line, rest, found := strings.Cut(buffer, "\n")
				if !found {
					return
				}
				buffer = rest
				if strings.TrimSpace(line) == "" {
					continue
				}
				var msg event
				if err := json.Unmarshal([]byte(line), &msg); err != nil {
					select {
					case parseErrors <- err:
					default:
					}
					return
				}
				select {
				case messages <- msg:
				case <-ctx.Done():
					return
				}
			}
		},
		OnStderr: func(chunk []byte) { fmt.Fprint(os.Stderr, string(chunk)) },
	})
	if err != nil {
		return err
	}
	nextID := 0
	prompt := func(text string) error {
		nextID++
		id := strconv.Itoa(nextID)
		data, err := json.Marshal(map[string]string{"id": id, "type": "prompt", "message": text})
		if err != nil {
			return err
		}
		if _, err := agent.Write(ctx, append(data, '\n')); err != nil {
			return err
		}
		accepted, settled := false, false
		var lastAssistant assistantMessage
		for !accepted || !settled {
			select {
			case msg := <-messages:
				switch msg.Type {
				case "response":
					if msg.ID == id {
						if !msg.Success {
							return errors.New(msg.Error)
						}
						accepted = true
					}
				case "message_update":
					if msg.AssistantMessageEvent.Type == "text_delta" {
						fmt.Print(msg.AssistantMessageEvent.Delta)
					}
				case "message_end":
					if msg.Message.Role == "assistant" {
						lastAssistant = msg.Message
					}
				case "agent_settled":
					settled = true
				}
			case err := <-parseErrors:
				return err
			case <-agent.Done:
				return errors.New("Pi closed before completing the task")
			case <-ctx.Done():
				return ctx.Err()
			}
		}
		if lastAssistant.Role == "" || lastAssistant.StopReason == "error" || lastAssistant.StopReason == "aborted" {
			return fmt.Errorf("Pi did not complete the response: %s", lastAssistant.ErrorMessage)
		}
		fmt.Println()
		return nil
	}
	if err := prompt("Read meeting.md and write actions.md with actions, owners and deadlines. Mark unagreed deadlines explicitly."); err != nil {
		return err
	}
	if err := prompt("Pavel has now confirmed a deadline of 2026-09-22. Update his action in actions.md; keep the other action unchanged."); err != nil {
		return err
	}
	report, err := sandbox.Files.ReadText(ctx, "/home/user/actions.md", "")
	if err != nil {
		return err
	}
	fmt.Println("actions.md\n" + report)
	return nil
}
func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

A response with success: true acknowledges the prompt. UI text arrives in message_update → assistantMessageEvent → text_delta. The handler waits for agent_settled and checks the final assistant message: Pi may still retry automatically after agent_end.

The second prompt goes to the same process after the first task finishes. The sandbox is deleted only after reading the updated actions.md. See the Pi protocol for other commands, including aborting a task and selecting a saved session.

Pi ​

Connect ​

Extract meeting actions ​

Events and follow-up questions ​

Pi

Connect

Extract meeting actions

Events and follow-up questions