# Languages and tools

What every sandbox has before its first command: the languages, build tools, coding agents and assistants a task asks for most.

Every sandbox starts from the same image: Ubuntu 24.04 on x86-64, with what follows installed and on the `PATH` a command is given. Nothing has to be installed first, and anything else can be: commands run as root.

## Languages

| Language | Version | Commands |
| --- | --- | --- |
| Python | 3.12, with pip, venv and uv 0.13 | `python3`, `pip`, `uv`, `uvx` |
| Node.js | 24, with npm and pnpm 12 | `node`, `npm`, `npx`, `pnpm` |
| Bun | 1.4 | `bun`, `bunx` |
| Deno | 2.9 | `deno` |
| Go | 1.27 | `go`, `gofmt` |
| Rust | 1.99, with clippy and rustfmt, through rustup | `rustc`, `cargo`, `rustup` |
| Java | OpenJDK 21, with Maven 3.8 and Gradle 9.8 | `java`, `javac`, `mvn`, `gradle` |
| Ruby | 3.2, with gem and Bundler | `ruby`, `gem`, `bundle` |
| PHP | 8.3, with Composer | `php`, `composer` |
| C and C++ | GCC 13, with make, CMake 3.28, Ninja and pkg-config | `gcc`, `g++`, `make`, `cmake`, `ninja` |

## Tools

| What | Commands |
| --- | --- |
| Docker | `docker`, with `docker compose` and BuildKit through `docker buildx` |
| Git and the GitHub CLI | `git`, `gh` |
| Search and data | `rg` (ripgrep), `jq`, `curl`, `zip`, `unzip` |
| Audio and video | `ffmpeg` 6.1 |
| A shell that outlives a connection | `tmux` |
| A browser | `google-chrome` and `playwright-cli`: see [Browser](https://agental.io/docs/browser) |

## Coding agents

Nine coding agents are installed. Each signs in to its model with your own key. Keep the key as a secret of the sandbox's [template](https://agental.io/docs/templates), under the name the tool reads, such as `ANTHROPIC_API_KEY` for Claude Code, and it reaches every command.

| Agent | Version | Command |
| --- | --- | --- |
| Claude Code | the latest on the day the image was built | `claude` |
| Codex | the latest on the day the image was built | `codex` |
| opencode | the latest on the day the image was built | `opencode` |
| Gemini CLI | the latest on the day the image was built | `gemini` |
| pi | 1.3.0 | `pi` |
| Cursor CLI | 2026.10.14 | `cursor-agent`, `agent` |
| Prime Agent | 0.10.0 | `prime-agent` |
| Kimi Code | 2.2.0 | `kimi` |
| Mistral Vibe | 2.26.1 | `vibe` |

```shell
cd /opt/agental/app && claude -p "make the failing test pass" --dangerously-skip-permissions
```

- Commands run as root, and Claude Code skips its permission prompts as root only when it is told it is in a sandbox. `claude` here tells it so: the machine is yours alone.
- An agent run with `-p` or `exec` answers and ends. For a longer task, start it in the background as in [Running commands](https://agental.io/docs/commands#background-work).
- The agents with a version in the table are pinned at it, and each file they came from was checked against a sum when the image was built. Cursor's CLI does not update itself here, and Kimi Code does not install its updates.
- Kimi Code reads no key from the environment by itself. Sign in with `/login` in `kimi`, or add a provider to `/root/.kimi-code/config.toml` whose `api_key_env` names the secret, such as `KIMI_API_KEY`.

## Assistants

OpenClaw and Hermes are assistants: you talk to one from a chat app such as Telegram, Slack or WhatsApp, and it keeps working between your messages. Each is installed, with its settings and its folder, and its gateway, the program that connects it to chat apps and keeps it running, is off. Nothing starts it until you do.

| Assistant | Version | Command | Its own files |
| --- | --- | --- | --- |
| OpenClaw | 2026.10.3 | `openclaw` | `/root/.openclaw` |
| Hermes Agent | 0.22.2 | `hermes` | `/root/.hermes` |

```shell
openclaw onboard
nohup openclaw gateway > /root/openclaw-gateway.log 2>&1 < /dev/null &
```

- Set one up with `openclaw onboard` or `hermes setup`, over [SSH](https://agental.io/docs/ssh) or on the desktop: each asks for a model key and the chat apps to connect. Its key can also be a secret of the template, as for the coding agents.
- Start its gateway in the background, as above, or with `hermes gateway run`. A gateway stops when the sandbox stops, and is started again by you after it starts. To keep an assistant answering, keep its sandbox running.
- Its gateway listens only on the sandbox's own `127.0.0.1` unless you change that, OpenClaw's at port 18789. Most chat apps are reached by a connection the gateway opens itself. One that has to call the gateway needs a [public address](https://agental.io/docs/ports) for its port.
- To have a gateway start by itself, `openclaw gateway install` and `hermes gateway install` make it a service, as each one's own docs describe.
- Hermes runs on a Python, Node.js, ripgrep and ffmpeg of its own, which its installer brought. Its browser and its computer-use driver were left out: install them with `hermes pm install agent-browser` and `hermes pm install cua-driver` if a task asks for them.

## What the agents are told

Each agent starts already knowing where it is, so a prompt can start with the task. It reads a short note with its standing instructions, every time: that it is root on an agental sandbox, to work in `/opt/agental`, that the disk outlasts a stop and running processes do not, to put long work in the background, to have a server listen on `0.0.0.0`, and that `AGENTAL_SANDBOX_ID` and `AGENTAL_API_URL` name its sandbox. Two skills, which it loads when a task asks for them, say more: `agental`, about the machine and about calling the API on its own sandbox, and `playwright-cli`, about driving the browser.

| Agent | The note | The skills |
| --- | --- | --- |
| Claude Code | `/root/.claude/CLAUDE.md` | `/root/.claude/skills` |
| Codex | `/root/.codex/AGENTS.md` | `/etc/codex/skills` |
| opencode | `/root/.config/opencode/AGENTS.md` | `/root/.claude/skills`, which it reads as well |
| Gemini CLI | `/root/.gemini/GEMINI.md` | `/root/.gemini/skills` |
| pi | `/root/.pi/agent/AGENTS.md` | `/root/.pi/agent/skills` |
| Cursor CLI | `/.cursor/rules/agental.mdc`, a rule it always applies, wherever it works | `/root/.cursor/skills` |
| Prime Agent | `/root/.prime/agent/AGENTS.md` | `/root/.prime/agent/skills` |
| Kimi Code | `/root/.kimi-code/AGENTS.md` | `/root/.kimi-code/skills` |
| Mistral Vibe | `/root/.vibe/AGENTS.md` | `/root/.vibe/skills` |
| Hermes | `/root/.hermes/SOUL.md`, after its own words there | `/root/.hermes/skills` |
| OpenClaw | `/root/.openclaw/workspace/AGENTS.md`, after its own words there | `/root/.openclaw/skills` |

- The `agental` skill calls the API only when you have given the agent a key, as a secret of the template such as `AGENTAL_API_KEY`, and then only on its own sandbox and the forks it made of it: to give a port an address, to fork the sandbox when you asked it to, run commands in the forks and delete them when it is done, to write to you by email, or to stop the sandbox when you asked it to. Give it a [key that can do only that](https://agental.io/docs/api-keys), limited to its sandbox: `email.send` alone, for an agent that only needs to write to you, or `sandbox.fork`, `exec` and `sandbox.delete-own` for one that forks.
- Your own rules go where the agent finds them on any computer: an `AGENTS.md` or `CLAUDE.md` in the project it works in, or more lines in the files above. A [snapshot](https://agental.io/docs/snapshots) keeps them for the next sandbox.
- A sandbox made from an image built before these were added has neither the note nor the `agental` skill. The variables are in its commands all the same.

## Installing more

- `npm install -g` works as it does on any Ubuntu machine, and so does `apt-get install -y` after `apt-get update`, which brings the package lists up to date.
- Packages install without their docs, man pages and translations, as in Ubuntu's minimal images. To have them, remove `/etc/dpkg/dpkg.cfg.d/01-agental-nodoc` and install the package again.
- Ubuntu keeps `pip install` to virtual environments, and refuses it outside one. Make one with `uv venv` or `python3 -m venv`, or install a Python tool with `uv tool install`.
- A command's `PATH` puts `/root/.local/bin`, `/root/.cargo/bin`, `/root/go/bin` and `/root/.bun/bin` first, where `uv tool install`, `cargo install`, `go install` and `bun add -g` put what they install. The next command finds it, and a newer copy there is used before the image's own.
- To start every new sandbox with what you installed, take a [snapshot](https://agental.io/docs/snapshots) and have its template start sandboxes from it.
- A sandbox keeps the versions it was made with. A sandbox made after the image is built again has the newer ones.

---

Every page of these docs as Markdown: [llms.txt](https://agental.io/llms.txt)