---
title: "Claude Code, Codex и OpenCode в песочнице | Pethost Agent Sandboxes"
description: "Дайте Claude Code, Codex или OpenCode промпт в песочнице одним вызовом, получайте его вызовы инструментов потоком и подключите его без ключа внутри песочницы."
---

[Документация Agent Sandboxes](https://pethost.dev/ru/docs/sandboxes/) · Задачи

# Claude Code, Codex и OpenCode в песочнице

Обновлено 22 ноября 2026 г. · 9 мин чтения

Claude Code, Codex и OpenCode установлены в каждой песочнице. Один вызов дает агенту промпт, другой потоком присылает каждое сообщение и вызов инструмента за его ход, а его API-ключ никогда не попадает в песочницу: прокси исходящего трафика добавляет его в запросы агента на выходе.

**Коротко**

- **`PromptAgent`** дает агенту промпт в новом или уже существующем разговоре и ждет его хода до 45 с: состояние хода и последнее сообщение агента.
- **Три агента:** `CLAUDE_CODE` (по умолчанию), `CODEX` и `OPENCODE`, каждый управляется через свой официальный SDK со всеми разрешениями: граница — сама песочница.
- **Вход через секрет:** привяжите `ANTHROPIC_API_KEY` или `OPENAI_API_KEY` к секрету рабочего пространства. OpenCode работает вообще без ключа.
- **`WatchConversation`** присылает потоком промпты, сообщения, вызовы инструментов с их входом и выходом и конец каждого хода.

### Step 1: Сохраните ключ агента как секрет

Секрет — это значение, которое хранит рабочее пространство и которого нет ни в одной песочнице, вместе с хостами, куда его можно отправлять. Задайте его один раз из программы или через CLI, где значение берется из вашего собственного окружения, и никогда из промпта.

Python

```
import os

sandboxes.set_secret("anthropic", value=os.environ["ANTHROPIC_API_KEY"], hosts=["api.anthropic.com"])
```

TypeScript

```
await sandboxes.setSecret({
  name: "anthropic",
  value: process.env.ANTHROPIC_API_KEY!,
  hosts: ["api.anthropic.com"],
});
```

Go

```
_, err = client.SetSecret(ctx, &sandboxes.SetSecretRequest{
	Name:  "anthropic",
	Value: os.Getenv("ANTHROPIC_API_KEY"),
	Hosts: []string{"api.anthropic.com"},
})
```

Rust

```
sandboxes
    .set_secret(SetSecretRequest {
        name: "anthropic".into(),
        value: std::env::var("ANTHROPIC_API_KEY")?,
        hosts: vec!["api.anthropic.com".into()],
        ..Default::default()
    })
    .await?;
```

CLI

```
$ printf %s "$ANTHROPIC_API_KEY" | pethost sandbox secret set anthropic --host api.anthropic.com
✓ Set the secret anthropic for api.anthropic.com. Bind it:  --env <VARIABLE>=secret:anthropic
anthropic
```

### Step 2: Создайте песочницу, которая его привязывает

Привяжите переменную агента к секрету. Внутри песочницы в переменной лежит заглушка, `phs_…`; прокси исходящего трафика меняет ее на ключ в заголовках запросов к `api.anthropic.com`.

Python

```
from pethost.sandboxes import Environment, EnvVar, SandboxSettings

sandbox = sandboxes.create_sandbox(
    "base",
    name="agent",
    settings=SandboxSettings(
        environment=Environment(variables=[EnvVar(name="ANTHROPIC_API_KEY", secret="anthropic")]),
    ),
)
sandbox_id = sandbox.sandbox_id
```

TypeScript

```
const sandbox = await sandboxes.createSandbox({
  template: "base",
  name: "agent",
  settings: { environment: { variables: [{ name: "ANTHROPIC_API_KEY", secret: "anthropic" }] } },
});
const sandboxId = sandbox.sandboxId;
```

Go

```
sandbox, err := client.CreateSandbox(ctx, &sandboxes.CreateSandboxRequest{
	Template: "base",
	Name:     "agent",
	Settings: &sandboxes.SandboxSettings{Environment: &sandboxes.Environment{Variables: []sandboxes.EnvVar{
		{Name: "ANTHROPIC_API_KEY", Source: sandboxes.EnvVarSecret("anthropic")},
	}}},
})
if err != nil {
	log.Fatal(err)
}
id := sandbox.SandboxID
```

Rust

```
let key = EnvVar { name: "ANTHROPIC_API_KEY".into(), source: Some(EnvVarSource::Secret("anthropic".into())) };
let sandbox = sandboxes
    .create_sandbox(CreateSandboxRequest {
        template: "base".into(),
        name: "agent".into(),
        settings: Some(SandboxSettings {
            environment: Some(Environment { variables: vec![key] }),
            ..Default::default()
        }),
        ..Default::default()
    })
    .await?;
let id = sandbox.sandbox_id.clone();
```

CLI

```
$ pethost sandbox new --name agent --env ANTHROPIC_API_KEY=secret:anthropic
✓ Made sandbox agent (kjxa3j9hvg9qmmqe): default, running, from base@17, in <1 s
kjxa3j9hvg9qmmqe
Next:   pethost sandbox run kjxa3j9hvg9qmmqe -- <command>   ·   pethost sandbox shell kjxa3j9hvg9qmmqe
```

MCP

```
CreateSandbox {"name": "agent", "settings": {"environment": {"variables": [{"name": "ANTHROPIC_API_KEY", "secret": "anthropic"}]}}}
```

### Step 3: Дайте агенту промпт и следите за его ходом

`PromptAgent` с `wait_seconds` 0 отвечает, как только ход начался. Затем `WatchConversation` присылает то, что делает агент, по мере того как он это делает, и ход таким, каким он завершился: состояние, последнее сообщение (`reply`, до 16 KiB) и потраченные токены.

Пример использует OpenCode с одной из его бесплатных моделей, `opencode/big-pickle`, поэтому ключ не нужен; Claude Code и Codex работают так же, когда их ключ привязан как секрет: уберите `model`, для Claude Code уберите и `agent`, а для Codex задайте в нём `CODEX`.

Python

```
from pethost.sandboxes import Agent

turn = sandboxes.prompt_agent(
    sandbox_id,
    prompt="Write a FizzBuzz in Python in fizz.py, with a test, and run the test.",
    agent=Agent.OPENCODE,
    model="opencode/big-pickle",
    wait_seconds=0,
)
for event in sandboxes.watch_conversation(sandbox_id, conversation_id=turn.conversation_id):
    if event.tool_call is not None:
        print("tool:", event.tool_call.name)
    elif event.message is not None:
        print("says:", event.message)
    elif event.turn_end is not None and event.turn_id == turn.turn_id:
        print(event.turn_end.state.name, event.turn_end.output_tokens, "tokens out")
        break
# tool: bash
# tool: write
# tool: write
# tool: bash
# tool: bash
# says: Created `fizz.py` and `test_fizz.py`; `python3 -m unittest test_fizz -v` passes.
# DONE 338 tokens out
```

TypeScript

```
const turn = await sandboxes.promptAgent({
  sandboxId,
  prompt: "Write a FizzBuzz in Python in fizz.py, with a test, and run the test.",
  agent: Agent.OPENCODE,
  model: "opencode/big-pickle",
  waitSeconds: 0,
});
for await (const event of sandboxes.watchConversation({ sandboxId, conversationId: turn.conversationId })) {
  if (event.event === "toolCall") console.log("tool:", event.toolCall.name);
  if (event.event === "message") console.log("says:", event.message);
  if (event.event === "turnEnd" && event.turnId === turn.turnId) {
    console.log(event.turnEnd.state, event.turnEnd.outputTokens, "tokens out");
    break;
  }
}
```

Go

```
turn, err := client.PromptAgent(ctx, &sandboxes.PromptAgentRequest{
	SandboxID:   id,
	Prompt:      "Write a FizzBuzz in Python in fizz.py, with a test, and run the test.",
	Agent:       sandboxes.AgentOpencode,
	Model:       "opencode/big-pickle",
	WaitSeconds: new(uint32(0)),
})
if err != nil {
	log.Fatal(err)
}
events := client.WatchConversation(ctx, &sandboxes.WatchConversationRequest{SandboxID: id, ConversationID: turn.ConversationID})
watch:
for event, err := range events {
	if err != nil {
		log.Fatal(err)
	}
	switch e := event.Event.(type) {
	case sandboxes.AgentEventToolCall:
		fmt.Println("tool:", e.Name)
	case sandboxes.AgentEventMessage:
		fmt.Println("says:", string(e))
	case sandboxes.AgentEventTurnEnd:
		if event.TurnID == turn.TurnID {
			fmt.Println(e.State, e.OutputTokens, "tokens out")
			break watch
		}
	}
}
```

Rust

```
let turn = sandboxes
    .prompt_agent(PromptAgentRequest {
        sandbox_id: id.clone(),
        prompt: "Write a FizzBuzz in Python in fizz.py, with a test, and run the test.".into(),
        agent: Agent::Opencode,
        model: "opencode/big-pickle".into(),
        wait_seconds: Some(0),
        ..Default::default()
    })
    .await?;
let mut events = sandboxes.watch_conversation(WatchConversationRequest {
    sandbox_id: id.clone(),
    conversation_id: turn.conversation_id.clone(),
    ..Default::default()
});
while let Some(event) = events.next().await {
    let event = event?;
    match event.event {
        Some(AgentEventEvent::ToolCall(call)) => println!("tool: {}", call.name),
        Some(AgentEventEvent::Message(text)) => println!("says: {text}"),
        Some(AgentEventEvent::TurnEnd(end)) if event.turn_id == turn.turn_id => {
            println!("{:?} {} tokens out", end.state, end.output_tokens);
            break;
        }
        _ => {}
    }
}
```

CLI

```
$ pethost sandbox agent agent --agent opencode --model opencode/big-pickle 'Write a FizzBuzz in Python in fizz.py, with a test, and run the test.'
opencode · conversation dk5p1kaxc1mj
› bash: ls -la /home/user
› write: def fizzbuzz(n): if n % 15 == 0: return "FizzBuzz" if n % 3 == 0: return "Fizz" if n % 5 == 0: retur…
› write: import unittest from fizz import fizzbuzz, fizzbuzz_sequence class FizzBuzzTest(unittest.TestCase): …
› bash: python3 -m unittest -v test_fizz.py
Running the test with Python's standard `unittest` runner.
Created `fizz.py` and `test_fizz.py`. Tests passed: 2/2 via `python3 -m unittest -v test_fizz.py`.
done · opencode · conversation dk5p1kaxc1mj · 33k tokens in, 1.1k out
```

### Step 4: Продолжайте в том же разговоре

Передайте `conversation_id` хода со следующим промптом, и агент продолжит с тем, что уже знает. Разговор выполняет по одному ходу за раз: промпт, отправленный, пока идет ход, встает за ним в очередь (QUEUED). `GetAgentTurn` снова ждет хода, до 45 с за вызов, а `StopAgentTurn` сразу его завершает.

Python

```
from pethost.sandboxes import AgentTurnState

next_turn = sandboxes.prompt_agent(sandbox_id, prompt="Now make it read n from argv.", conversation_id=turn.conversation_id)
while next_turn.state in (AgentTurnState.QUEUED, AgentTurnState.RUNNING):
    next_turn = sandboxes.get_agent_turn(sandbox_id, turn_id=next_turn.turn_id)
print(next_turn.state.name, next_turn.reply)
# DONE `fizz.py` now reads `n` from `sys.argv[1]`; tests pass and CLI works (`python3 fizz.py 15` → `FizzBuzz`).
```

TypeScript

```
let nextTurn = await sandboxes.promptAgent({
  sandboxId,
  prompt: "Now make it read n from argv.",
  conversationId: turn.conversationId,
});
while (nextTurn.state === AgentTurnState.QUEUED || nextTurn.state === AgentTurnState.RUNNING) {
  nextTurn = await sandboxes.getAgentTurn({ sandboxId, turnId: nextTurn.turnId });
}
console.log(nextTurn.state, nextTurn.reply);
```

Go

```
next, err := client.PromptAgent(ctx, &sandboxes.PromptAgentRequest{
	SandboxID:      id,
	Prompt:         "Now make it read n from argv.",
	ConversationID: turn.ConversationID,
})
for err == nil && (next.State == sandboxes.AgentTurnStateQueued || next.State == sandboxes.AgentTurnStateRunning) {
	next, err = client.GetAgentTurn(ctx, &sandboxes.GetAgentTurnRequest{SandboxID: id, TurnID: next.TurnID})
}
if err != nil {
	log.Fatal(err)
}
fmt.Println(next.State, next.Reply)
```

Rust

```
let mut next = sandboxes
    .prompt_agent(PromptAgentRequest {
        sandbox_id: id.clone(),
        prompt: "Now make it read n from argv.".into(),
        conversation_id: turn.conversation_id.clone(),
        ..Default::default()
    })
    .await?;
while matches!(next.state, AgentTurnState::Queued | AgentTurnState::Running) {
    let ask = GetAgentTurnRequest { sandbox_id: id.clone(), turn_id: next.turn_id.clone(), ..Default::default() };
    next = sandboxes.get_agent_turn(ask).await?;
}
println!("{:?} {}", next.state, next.reply);
```

CLI

```
$ pethost sandbox agent agent --conversation dk5p1kaxc1mj 'Now make it read n from argv.'
opencode · conversation dk5p1kaxc1mj
› read: /home/user/fizz.py
› read: /home/user/test_fizz.py
› edit: /home/user/fizz.py
› edit: /home/user/fizz.py
› edit: /home/user/test_fizz.py
› edit: /home/user/test_fizz.py
› bash: python3 -m unittest -v test_fizz.py
› bash: python3 fizz.py 5
`fizz.py` now reads `N` from argv via `main()` (fizz.py:19). `python3 fizz.py 5` prints `1, 2, Fizz, 4, Buzz`. Tests: 3/3 passed.
done · opencode · conversation dk5p1kaxc1mj · 61.4k tokens in, 1.6k out
```

## Три агента

| Агент | `agent` | Вход | Имя модели |
| --- | --- | --- | --- |
| Claude Code | `CLAUDE_CODE`, по умолчанию | `ANTHROPIC_API_KEY` или `claude auth login` | `claude-opus-5-5` |
| Codex | `CODEX` | `OPENAI_API_KEY` или `codex login --device-auth` | `gpt-6.1` |
| OpenCode | `OPENCODE` | Ничего: свои бесплатные модели или ключ провайдера | `anthropic/claude-opus-5-5` |

Новый разговор принимает `agent` (если не задан — Claude Code), `model` так, как этот агент называет свои модели (если не задана — модель агента по умолчанию), и `cwd`, свою рабочую папку (если не задана — `/home/user`). Каждый агент работает через свой SDK со всеми разрешениями: Claude Code с `bypassPermissions`, Codex с полным доступом и без подтверждений, OpenCode со всеми разрешенными инструментами. Ничто не просит вас подтвердить команду, потому что граница — песочница, отдельная ВМ. CLI тоже есть в `PATH`, как `claude`, `codex` и `opencode`, для человека в терминале.

## Как подключить агента

- **Секрет, привязанный к его переменной,** как выше: ключ остается в рабочем пространстве, а прокси добавляет его в запросы агента к хостам секрета. Новое значение работает сразу. Как устроена подстановка, рассказывает страница [«Секреты и исходящий трафик»](https://pethost.dev/ru/docs/sandboxes/secrets-and-egress/#secrets).
- **Вход в терминале:** человек открывает терминал песочницы и выполняет `claude auth login` или `codex login --device-auth`. Вход хранится на диске песочницы, как любой файл.
- **Без входа, с OpenCode:** без ключа провайдера он использует собственные бесплатные модели OpenCode.

Промпт агенту, который не может достучаться до своей модели, получает отказ `FAILED_PRECONDITION` с `AgentSignIn`, где названы переменная, которую нужно привязать (`variable`), и команда, которую вместо этого может выполнить человек (`sign_in_command`).

## Ходы и что их переживает

Ход стоит в очереди (QUEUED) за идущим ходом разговора, затем идет (RUNNING), а потом завершается: DONE, FAILED (`failure_message` говорит почему) или STOPPED через `StopAgentTurn`; LOST — если песочница потеряла память, пока он шел. Когда ход заканчивается, вместе с ним завершаются агент и его помощники, но то, что его команды оставили работать в фоне, например dev-сервер, продолжает работать. Пока ход идет, песочница не засыпает.

История разговора лежит на диске песочницы: пауза ее сохраняет, форк переносит в каждую копию, так что каждая копия может продолжить с той же точки. Шаблон — нет: песочницы из него запускаются без разговоров. `ListConversations` перечисляет разговоры песочницы с токенами, которые потратил каждый, а вкладка «Агенты» в панели показывает их по ходу работы.

То, что агент пишет, читает и запускает, приходит из кода и страниц, с которыми он работает: показывайте его сообщения и вывод инструментов как данные, а не как инструкции своей модели.

## Если не работает

- **`FAILED_PRECONDITION` с `AgentSignIn`:** до модели агента не доходит ни один ключ. Привяжите `variable` к секрету через `UpdateSandbox` (окружение действует на процессы, запущенные после этого), попросите человека выполнить `sign_in_command` или используйте OpenCode.
- **Ход сразу FAILED с 403 от хоста модели:** настройки исходящего трафика песочницы не разрешают этот хост, или его нет среди хостов секрета. Добавьте `api.anthropic.com` или `api.openai.com` и туда, и туда.
- **Ход остается в QUEUED:** идет другой ход этого разговора. Дождитесь его, остановите или начните новый разговор.
- **Ход стал LOST:** песочница остановилась, пока он шел, или ее серверу не хватило памяти. Возобновите песочницу и отправьте промпт снова; файлы, которые агент записал до этого, лежат на ее диске.
- **`INVALID_ARGUMENT` на `cwd`:** существующий разговор сохраняет папку, в которой начался. Не передавайте `cwd` или начните новый разговор.

## Вопросы

### Какие агенты для кода можно запускать в песочнице?

Claude Code, Codex и OpenCode, все три установлены в `base`, каждый управляется через свой официальный SDK.

### Попадает ли мой API-ключ в песочницу?

Нет, если это привязанный секрет: в песочнице лежит заглушка, а прокси исходящего трафика подставляет ключ в запросы только к хостам секрета.

### Можно ли запустить агента для кода без API-ключа?

Да, OpenCode: без ключа провайдера он использует собственные бесплатные модели OpenCode.

### Спрашивает ли агент, прежде чем выполнять команды?

Нет. У него все разрешения, потому что песочница — отдельная ВМ, в которой нет ничего вашего, кроме того, что вы туда положили. Для недоверенной работы сужайте ее исходящий трафик.

### Переживают ли разговоры паузу?

Да, а форк переносит их в каждую копию. Шаблон их не сохраняет.

[ПредыдущаяПорты и превью: адреса песочницы](https://pethost.dev/ru/docs/sandboxes/ports-and-previews/) [СледующаяComputer use: Chrome на рабочем столе в песочнице](https://pethost.dev/ru/docs/sandboxes/computer-use/)

## Попробуйте Pethost Agent Sandboxes

Пробный период на 7 дней: 1 $ использования и 4 vCPU, нужна карта. Затем тариф от 20 $ в месяц, в который входит столько же использования.

[Начать пробный период](https://console.pethost.dev/)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Шаблоны](https://pethost.dev/ru/templates/)
- [О нас](https://pethost.dev/about/)
- [Документация](https://pethost.dev/docs/)
- [Блог](https://pethost.dev/ru/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Плагин](https://github.com/pethost-dev/plugin)
- [Условия](https://pethost.dev/terms/)
- [Конфиденциальность](https://pethost.dev/privacy/)
- [Возвраты](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Базы данных

- [Postgres](https://pethost.dev/ru/postgres/)
- [Valkey](https://pethost.dev/ru/valkey/)

Agent Sandboxes

- [Песочницы](https://pethost.dev/ru/sandboxes/)
- [Цены](https://pethost.dev/ru/sandboxes/#pricing)
- [Документация](https://pethost.dev/ru/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Сравнения

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/ru/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/ru/blog/coolify-cloud-vs-dokploy-cloud/)
- [Цены Railway, Render и Fly.io](https://pethost.dev/ru/blog/railway-vs-render-vs-fly-io-pricing/)
- [Управляемый хостинг Docker Compose](https://pethost.dev/ru/blog/managed-docker-compose-hosting/)

Альтернативы

- [Альтернативы Railway](https://pethost.dev/ru/blog/railway-alternatives/)
- [Альтернативы Heroku](https://pethost.dev/ru/blog/heroku-alternatives/)
- [Альтернативы Dokploy](https://pethost.dev/ru/blog/dokploy-alternatives/)
- [Альтернативы Coolify](https://pethost.dev/ru/blog/coolify-alternatives/)
- [Альтернативы Render](https://pethost.dev/ru/blog/render-alternatives/)
- [Альтернативы Sliplane](https://pethost.dev/ru/blog/sliplane-alternatives/)
