Claude Code

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.

Claude Code is an Anthropic agent that reads and changes files, runs commands, and connects external tools. AgentBox runs it inside a separate sandbox. The claude template already includes the CLI.

Connect

Install the AgentBox SDK and set AGENTBOX_API_KEY and ANTHROPIC_API_KEY in your application environment. The example passes the Anthropic key only to the agent command. --model sonnet selects a Claude Code model alias. You can instead specify a full model name available to your key.

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.

Compare price lists

The example uploads two supplier price lists as CSV files. Claude matches products by SKU and writes changes.md with price differences in RUB and percent, unchanged prices, and new items. In this dataset, A-100 increases by RUB 200 (20%), B-200 stays unchanged, and C-300 is new.

mjs

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

const apiKey = process.env.ANTHROPIC_API_KEY;
if (!apiKey) throw new Error("ANTHROPIC_API_KEY is required");
const proxy =
  process.env.SANDBOX_PROXY_URL ?? "https://sandbox-proxy.agentbox.ru:65181";
const sandbox = await Sandbox.create("claude", { timeoutMs: 600_000 });
try {
  await sandbox.files.makeDir("/home/user/work");
  await sandbox.files.write(
    "/home/user/work/prices-before.csv",
    "sku,price_rub\nA-100,1000\nB-200,2500\n",
  );
  await sandbox.files.write(
    "/home/user/work/prices-after.csv",
    "sku,price_rub\nA-100,1200\nB-200,2500\nC-300,800\n",
  );
  const handle = await sandbox.commands.run(
    "claude -p --model sonnet --dangerously-skip-permissions --output-format json",
    {
      cwd: "/home/user/work",
      timeoutMs: 300_000,
      background: true,
      stdin: true,
      envs: {
        ANTHROPIC_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(
    "Compare prices-before.csv and prices-after.csv by sku. Write changes.md with price changes in RUB and percent, unchanged items, and new items. Use only the supplied data.",
  );
  await handle.closeStdin();
  const result = await handle.wait();
  const response = JSON.parse(result.stdout);
  if (response.is_error) throw new Error(response.result ?? response.subtype);
  console.log(response.result);
  console.log(
    "changes.md\n" + (await sandbox.files.read("/home/user/work/changes.md")),
  );
} finally {
  await sandbox.kill();
}

import json
import os
import sys
from agentbox import Sandbox

api_key = os.environ["ANTHROPIC_API_KEY"]
proxy = os.getenv("SANDBOX_PROXY_URL", "https://sandbox-proxy.agentbox.ru:65181")
sandbox = Sandbox.create("claude", timeout=600)
try:
    sandbox.files.make_dir("/home/user/work")
    sandbox.files.write(
        "/home/user/work/prices-before.csv", "sku,price_rub\nA-100,1000\nB-200,2500\n"
    )
    sandbox.files.write(
        "/home/user/work/prices-after.csv",
        "sku,price_rub\nA-100,1200\nB-200,2500\nC-300,800\n",
    )
    handle = sandbox.commands.run(
        "claude -p --model sonnet --dangerously-skip-permissions --output-format json",
        cwd="/home/user/work",
        timeout=300,
        background=True,
        stdin=True,
        envs={
            "ANTHROPIC_API_KEY": api_key,
            "HTTPS_PROXY": proxy,
            "HTTP_PROXY": proxy,
            "NO_PROXY": "localhost,127.0.0.1",
        },
    )
    handle.send_stdin(
        "Compare prices-before.csv and prices-after.csv by sku. Write changes.md with price changes in RUB and percent, unchanged items, and new items. Use only the supplied data."
    )
    handle.close_stdin()
    result = handle.wait(on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr))
    response = json.loads(result.stdout)
    if response["is_error"]:
        raise RuntimeError(response.get("result") or response["subtype"])
    print(response["result"])
    print("changes.md\n" + sandbox.files.read("/home/user/work/changes.md"))
finally:
    sandbox.kill()

package main

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

func run() (err error) {
	apiKey, proxy := os.Getenv("ANTHROPIC_API_KEY"), os.Getenv("SANDBOX_PROXY_URL")
	if apiKey == "" {
		return errors.New("ANTHROPIC_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: "claude", 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/prices-before.csv", "sku,price_rub\nA-100,1000\nB-200,2500\n", nil); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/prices-after.csv", "sku,price_rub\nA-100,1200\nB-200,2500\nC-300,800\n", nil); err != nil {
		return err
	}
	handle, err := sandbox.Commands.Start(ctx, "sh", &agentbox.CommandOptions{
		Args: []string{"-lc", "claude -p --model sonnet --dangerously-skip-permissions --output-format json"}, Cwd: "/home/user/work", Stdin: true,
		Env:      map[string]string{"ANTHROPIC_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("Compare prices-before.csv and prices-after.csv by sku. Write changes.md with price changes in RUB and percent, unchanged items, and new items. Use only the supplied data.")); err != nil {
		return err
	}
	if err := handle.CloseStdin(ctx); err != nil {
		return err
	}
	result, err := handle.Wait(ctx)
	if err != nil {
		return err
	}
	var response struct {
		IsError bool   `json:"is_error"`
		Result  string `json:"result"`
		Subtype string `json:"subtype"`
	}
	if err := json.Unmarshal(result.Stdout, &response); err != nil {
		return err
	}
	if response.IsError {
		return fmt.Errorf("Claude Code: %s: %s", response.Subtype, response.Result)
	}
	fmt.Println(response.Result)
	report, err := sandbox.Files.ReadText(ctx, "/home/user/work/changes.md", "")
	if err != nil {
		return err
	}
	fmt.Println("changes.md\n" + report)
	return nil
}
func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

-p runs a task and exits. The application sends the task through stdin, closes the input stream, then waits for the result. --dangerously-skip-permissions bypasses Claude Code's permission checks and approval prompts. The agent uses its default toolset. The AgentBox sandbox provides the isolation boundary.

--output-format json returns response text in result, a session_id, and an is_error flag. The example checks that flag before reading the output file through the SDK. The finally block also deletes the sandbox on failure.

Read results and continue a session

The next example displays text as it is generated. Claude first compares the price lists, then receives a follow-up: add the purchase cost of 10 units of each existing product. History and files stay in the same sandbox.

mjs

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

const apiKey = process.env.ANTHROPIC_API_KEY;
if (!apiKey) throw new Error("ANTHROPIC_API_KEY is required");
const proxy =
  process.env.SANDBOX_PROXY_URL ?? "https://sandbox-proxy.agentbox.ru:65181";
const sandbox = await Sandbox.create("claude", { timeoutMs: 600_000 });
try {
  await sandbox.files.makeDir("/home/user/work");
  await sandbox.files.write(
    "/home/user/work/prices-before.csv",
    "sku,price_rub\nA-100,1000\nB-200,2500\n",
  );
  await sandbox.files.write(
    "/home/user/work/prices-after.csv",
    "sku,price_rub\nA-100,1200\nB-200,2500\nC-300,800\n",
  );
  async function execute(prompt, sessionId) {
    let pending = "";
    let result;
    let nextSessionId;
    function event(message) {
      if (
        message.type === "stream_event" &&
        message.event.delta?.type === "text_delta"
      ) {
        process.stdout.write(message.event.delta.text);
      }
      if (message.type === "result") result = message;
    }
    function onStdout(chunk) {
      pending += chunk;
      let newline;
      while ((newline = pending.indexOf("\n")) !== -1) {
        const line = pending.slice(0, newline);
        pending = pending.slice(newline + 1);
        if (line.trim()) event(JSON.parse(line));
      }
    }
    const handle = await sandbox.commands.run(
      "claude -p --model sonnet --dangerously-skip-permissions --output-format stream-json --verbose --include-partial-messages" +
        (sessionId ? ' --resume "$AGENT_SESSION_ID"' : ""),
      {
        cwd: "/home/user/work",
        timeoutMs: 300_000,
        background: true,
        stdin: true,
        envs: {
          ANTHROPIC_API_KEY: apiKey,
          HTTPS_PROXY: proxy,
          HTTP_PROXY: proxy,
          NO_PROXY: "localhost,127.0.0.1",
          AGENT_SESSION_ID: sessionId ?? "",
        },
        onStdout,
        onStderr: (chunk) => process.stderr.write(chunk),
      },
    );
    await handle.sendStdin(prompt);
    await handle.closeStdin();
    await handle.wait();
    if (pending.trim()) event(JSON.parse(pending));
    if (!result) throw new Error("Claude Code ended without a result");
    if (result.is_error)
      throw new Error(
        result.result ?? result.errors?.join("\n") ?? result.subtype,
      );
    nextSessionId = result.session_id;
    if (!nextSessionId)
      throw new Error("Claude Code did not return a session ID");
    console.log("\nSession:", nextSessionId);
    return nextSessionId;
  }
  const sessionId = await execute(
    "Compare prices-before.csv and prices-after.csv by sku. Write changes.md with price changes in RUB and percent, unchanged items, and new items.",
  );
  await execute(
    "Add a procurement summary to changes.md: calculate the cost of 10 units of each existing item before and after the change. Keep the original comparison.",
    sessionId,
  );
  console.log(
    "changes.md\n" + (await sandbox.files.read("/home/user/work/changes.md")),
  );
} finally {
  await sandbox.kill();
}

import json
import os
import sys
from agentbox import Sandbox

api_key = os.environ["ANTHROPIC_API_KEY"]
proxy = os.getenv("SANDBOX_PROXY_URL", "https://sandbox-proxy.agentbox.ru:65181")
sandbox = Sandbox.create("claude", timeout=600)
try:
    sandbox.files.make_dir("/home/user/work")
    sandbox.files.write(
        "/home/user/work/prices-before.csv", "sku,price_rub\nA-100,1000\nB-200,2500\n"
    )
    sandbox.files.write(
        "/home/user/work/prices-after.csv",
        "sku,price_rub\nA-100,1200\nB-200,2500\nC-300,800\n",
    )

    def execute(prompt, session_id=None):
        pending = ""
        result = None
        next_session_id = None

        def event(message):
            nonlocal result
            if message["type"] == "stream_event":
                delta = message["event"].get("delta", {})
                if delta.get("type") == "text_delta":
                    print(delta["text"], end="", flush=True)
            elif message["type"] == "result":
                result = message

        def on_stdout(chunk):
            nonlocal pending
            pending += chunk
            while "\n" in pending:
                line, pending = pending.split("\n", 1)
                if line.strip():
                    event(json.loads(line))

        handle = sandbox.commands.run(
            "claude -p --model sonnet --dangerously-skip-permissions --output-format stream-json --verbose --include-partial-messages"
            + (' --resume "$AGENT_SESSION_ID"' if session_id else ""),
            cwd="/home/user/work",
            timeout=300,
            background=True,
            stdin=True,
            envs={
                "ANTHROPIC_API_KEY": api_key,
                "HTTPS_PROXY": proxy,
                "HTTP_PROXY": proxy,
                "NO_PROXY": "localhost,127.0.0.1",
                "AGENT_SESSION_ID": session_id or "",
            },
        )
        handle.send_stdin(prompt)
        handle.close_stdin()
        handle.wait(
            on_stdout=on_stdout,
            on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr),
        )
        if pending.strip():
            event(json.loads(pending))
        if result is None:
            raise RuntimeError("Claude Code ended without a result")
        if result["is_error"]:
            raise RuntimeError(
                result.get("result") or result.get("errors") or result["subtype"]
            )
        next_session_id = result.get("session_id")
        if not next_session_id:
            raise RuntimeError("Claude Code did not return a session ID")
        print("\nSession:", next_session_id)
        return next_session_id

    session_id = execute(
        "Compare prices-before.csv and prices-after.csv by sku. Write changes.md with price changes in RUB and percent, unchanged items, and new items."
    )
    execute(
        "Add a procurement summary to changes.md: calculate the cost of 10 units of each existing item before and after the change. Keep the original comparison.",
        session_id,
    )
    print("changes.md\n" + sandbox.files.read("/home/user/work/changes.md"))
finally:
    sandbox.kill()

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"os"
	"strings"
	"time"

	"github.com/abox-dev/sdk/packages/go-sdk"
)

func run() (err error) {
	apiKey, proxy := os.Getenv("ANTHROPIC_API_KEY"), os.Getenv("SANDBOX_PROXY_URL")
	if apiKey == "" {
		return errors.New("ANTHROPIC_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: "claude", 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/prices-before.csv", "sku,price_rub\nA-100,1000\nB-200,2500\n", nil); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/prices-after.csv", "sku,price_rub\nA-100,1200\nB-200,2500\nC-300,800\n", nil); err != nil {
		return err
	}
	execute := func(prompt, sessionID string) (string, error) {
		var pending, nextSessionID string
		var streamErr error
		var result *struct {
			IsError   bool     `json:"is_error"`
			Result    string   `json:"result"`
			Subtype   string   `json:"subtype"`
			SessionID string   `json:"session_id"`
			Errors    []string `json:"errors"`
		}
		event := func(line string) {
			if strings.TrimSpace(line) == "" || streamErr != nil {
				return
			}
			var message struct {
				Type  string `json:"type"`
				Event struct {
					Delta struct {
						Type string `json:"type"`
						Text string `json:"text"`
					} `json:"delta"`
				} `json:"event"`
			}
			if err := json.Unmarshal([]byte(line), &message); err != nil {
				streamErr = err
				return
			}
			if message.Type == "stream_event" && message.Event.Delta.Type == "text_delta" {
				fmt.Print(message.Event.Delta.Text)
			}
			if message.Type == "result" {
				streamErr = json.Unmarshal([]byte(line), &result)
			}
		}
		commandCtx, stopCommand := context.WithTimeout(ctx, 5*time.Minute)
		defer stopCommand()
		args := []string{"-p", "--model", "sonnet", "--dangerously-skip-permissions", "--output-format", "stream-json", "--verbose", "--include-partial-messages"}
		if sessionID != "" {
			args = append(args, "--resume", sessionID)
		}
		handle, err := sandbox.Commands.Start(commandCtx, "claude", &agentbox.CommandOptions{
			Args: args, Cwd: "/home/user/work", Stdin: true,
			Env: map[string]string{"ANTHROPIC_API_KEY": apiKey, "HTTPS_PROXY": proxy, "HTTP_PROXY": proxy, "NO_PROXY": "localhost,127.0.0.1"},
			OnStdout: func(chunk []byte) {
				pending += string(chunk)
				for {
					line, rest, found := strings.Cut(pending, "\n")
					if !found {
						break
					}
					pending = rest
					event(line)
				}
			},
			OnStderr: func(chunk []byte) { fmt.Fprint(os.Stderr, string(chunk)) },
		})
		if err != nil {
			return "", err
		}
		if _, err := handle.Write(commandCtx, []byte(prompt)); err != nil {
			return "", err
		}
		if err := handle.CloseStdin(commandCtx); err != nil {
			return "", err
		}
		if _, err := handle.Wait(commandCtx); err != nil {
			return "", err
		}
		event(pending)
		if streamErr != nil {
			return "", streamErr
		}
		if result == nil {
			return "", errors.New("Claude Code ended without a result")
		}
		if result.IsError {
			return "", fmt.Errorf("Claude Code: %s: %s %s", result.Subtype, result.Result, strings.Join(result.Errors, "; "))
		}
		nextSessionID = result.SessionID
		if nextSessionID == "" {
			return "", errors.New("Claude Code did not return a session ID")
		}
		fmt.Println("\nSession:", nextSessionID)
		return nextSessionID, nil
	}
	sessionID, err := execute("Compare prices-before.csv and prices-after.csv by sku. Write changes.md with price changes in RUB and percent, unchanged items, and new items.", "")
	if err != nil {
		return err
	}
	if _, err := execute("Add a procurement summary to changes.md: calculate the cost of 10 units of each existing item before and after the change. Keep the original comparison.", sessionID); err != nil {
		return err
	}
	report, err := sandbox.Files.ReadText(ctx, "/home/user/work/changes.md", "")
	if err != nil {
		return err
	}
	fmt.Println("changes.md\n" + report)
	return nil
}

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

--output-format stream-json --verbose --include-partial-messages enables JSONL output. The handler buffers stdout chunks into complete lines and prints stream_event → event.delta.text when the delta type is text_delta.

The final result event contains is_error and session_id. Once the command succeeds, the application passes this ID to --resume and sends the next task through stdin. The second process continues the same conversation. The sandbox is deleted after reading the updated changes.md.

For this data, the cost of 10 units each of A-100 and B-200 increases from RUB 35,000 to RUB 37,000. The new C-300 item stays in the comparison but is excluded from this calculation. See the Claude Code guide for other options.

Claude Code ​

Connect ​

Compare price lists ​

Read results and continue a session ​

Claude Code

Connect

Compare price lists

Read results and continue a session