This is the multi-page printable view of this section. Click here to print.

Return to the regular view of this page.

AI Providers

1: Claude
2: Aider
3: Gemini
4: Mistral
5: OpenAI (Codex CLI)
6: Copilot (GitHub)
7: Continue

1 - Claude

Claude Code

Claude Code by Anthropic is a terminal-based AI coding assistant. It’s the default provider in aibox.

Setup

[ai]
harnesses = [
  { harness = "claude", enable = true, install = true },
]

Run aibox apply, then inside the container:

claude   # Launches Claude Code CLI

On first launch, Claude prompts for authentication via browser login.

Configuration

Claude’s configuration, cache, and account state are persisted under .aibox-home/ and mounted into the container. aibox preserves Claude’s primary config directory (.claude/), top-level account state (.claude.json), and XDG state/cache locations used by current Claude Code releases.

Key files:

.claude/settings.json — Claude Code settings
.claude.json — Claude Code account/install state
.cache/claude*, .config/claude/, .local/share/claude/, .local/state/claude/ — Claude Code login and runtime state
.claude/projects/ — Per-project memory and context
.claude/skills/<name>/SKILL.md — generated processkit command shims when Claude is enabled in processkit mode

The generated .claude/skills/ entries are adapters. The canonical skill instructions remain in context/skills/. Harness-only projects do not generate processkit command shims.

Audio (Voice)

Claude Code supports voice input. To enable it, configure audio bridging:

[audio]
enabled = true

MCP Integration

Claude Code’s native MCP client reads .mcp.json. aibox generates .mcp.json automatically on aibox apply, merging processkit built-in servers in processkit mode, team servers from aibox.toml [ai.mcp], and personal servers from .aibox-local.toml [mcp].

.mcp.json is gitignored — it is regenerated on every aibox apply and must not be committed.

To add MCP servers:

# aibox.toml — team-shared servers
[[ai.mcp.servers]]
name    = "github"
command = "npx"
args    = ["-y", "@modelcontextprotocol/server-github"]

# .aibox-local.toml — personal servers (not committed)
[[mcp.servers]]
name    = "my-internal-tool"
command = "npx"
args    = ["-y", "@acme/internal-mcp-server"]

tmux Integration

When Claude is configured as a provider, tmux layouts include a dedicated Claude pane:

dev layout: Claude gets its own window
focus layout: Claude gets its own window
cowork layout: Claude appears in a side-by-side pane next to the editor

2 - Aider

Aider

Aider is an open-source AI pair programming tool that works with multiple LLM providers from the terminal.

Setup

[ai]
harnesses = [
  { harness = "aider", enable = true, install = true },
]

Run aibox apply, then inside the container:

aider    # Launches Aider CLI

API Key

Aider requires an API key for the LLM provider you want to use. Set it in your environment:

[container.environment]
ANTHROPIC_API_KEY = "sk-ant-..."
# Or for OpenAI:
# OPENAI_API_KEY = "sk-..."

Alternatively, create a .aider.conf.yml in .aibox-home/.aider/.

Configuration

Aider’s configuration is persisted in .aibox-home/.aider/, mounted at /home/aibox/.aider/.

Installation

Aider is installed via uv tool install aider-chat — a fast, isolated Python tool installation.

3 - Gemini

Gemini

Gemini CLI is Google’s command-line interface for Gemini AI models.

Setup

[ai]
harnesses = [
  { harness = "gemini", enable = true, install = true },
]

Run aibox apply, then inside the container:

gemini   # Launches Gemini CLI

API Key

[container.environment]
GOOGLE_API_KEY = "..."

Configuration

Gemini’s configuration is persisted in .aibox-home/.gemini/, mounted at /home/aibox/.gemini/.

MCP Integration

Gemini CLI reads .gemini/settings.json. aibox generates this file automatically on aibox apply, merging processkit built-in servers in processkit mode, team servers from aibox.toml [ai.mcp], and personal servers from .aibox-local.toml [mcp].

.gemini/settings.json is gitignored — it is regenerated on every aibox apply and must not be committed.

To add MCP servers:

# aibox.toml — team-shared servers
[[ai.mcp.servers]]
name    = "github"
command = "npx"
args    = ["-y", "@modelcontextprotocol/server-github"]

# .aibox-local.toml — personal servers
[[mcp.servers]]
name    = "my-internal-tool"
command = "npx"
args    = ["-y", "@acme/internal-mcp-server"]

Installation

Gemini CLI is installed via npm (npm install -g @google/generative-ai-cli), with a pip fallback.

4 - Mistral

Mistral (SDK)

SDK addon — not an interactive CLI

The ai-mistral addon installs the mistralai Python SDK, not an interactive coding CLI. It is intended for projects that call the Mistral API programmatically. For an interactive coding experience, use Claude, Gemini, OpenAI Codex, or Copilot instead.

Mistral AI provides large language models via Python SDK.

Setup

[ai]
model_providers = ["mistral"]

[addons.ai-mistral.tools]
mistral = {}

mistral is retained as a legacy harness value for old configs, but it is not a current interactive CLI harness. Use the addon directly for SDK installs. Run aibox apply. Inside the container the mistralai Python SDK is available for scripting:

from mistralai import Mistral
client = Mistral(api_key="...")

API Key

[container.environment]
MISTRAL_API_KEY = "..."

MCP Integration

aibox generates .mcp.json (the Claude Code MCP format) on aibox apply when a compatible harness is enabled, merging processkit built-in servers in processkit mode, team servers from aibox.toml [ai.mcp], and personal servers from .aibox-local.toml [mcp]. A custom Mistral SDK-based tool you build can read MCP server registrations from this file.

.mcp.json is gitignored — it is regenerated on every aibox apply and must not be committed.

Installation

The Mistral AI SDK is installed via pip (pip install --no-cache-dir mistralai).

5 - OpenAI (Codex CLI)

OpenAI Codex CLI

Codex CLI is OpenAI’s open-source terminal coding agent. Built in Rust, GA since April 2025.

Setup

[ai]
harnesses = [
  { harness = "codex", enable = true, install = true },
]

Run aibox apply, then inside the container:

codex    # Launches OpenAI Codex CLI

API Key

[container.environment]
OPENAI_API_KEY = "sk-..."

Alternatively, use a ChatGPT Plus/Pro/Team/Enterprise account — Codex prompts for authentication on first launch.

Configuration

Codex’s home-directory state is persisted in .aibox-home/.codex/, mounted at /home/aibox/.codex/. This survives devcontainer rebuilds, so device sign-in only needs to be completed once per host cache unless you clear it.

Key files:

.aibox-home/.codex/auth.json — cached ChatGPT/device authentication reused across rebuilds
.aibox-home/.codex/rules/ — home-directory Codex rules and local state
.aibox-home/.codex/sessions/ — Codex session history
.aibox-home/.codex/prompts/pk-*.md — generated processkit custom-prompt aliases

Separately, aibox also generates project-local .codex/config.toml MCP server registration. In processkit mode it also generates .codex/hooks.json processkit hook configuration.

processkit commands

After aibox apply, processkit workflows are available through both Codex invocation surfaces:

Type $pk-resume, $pk-doctor, and similar names to invoke the generated project skills under .agents/skills/. You can also select them through /skills.
Type /prompts:pk-resume, /prompts:pk-doctor, and similar names to use the generated custom-prompt aliases persisted under .aibox-home/.codex/prompts/.

Codex reserves top-level slash commands and does not support registering a custom /pk-resume command. Custom prompts always use the /prompts: namespace. Restart the Codex session after the first aibox apply if newly generated prompt aliases do not appear immediately.

MCP Integration

Codex has a native MCP client. aibox generates .codex/config.toml automatically on aibox apply, merging processkit MCP entries in processkit mode, team servers from aibox.toml [ai.mcp], and personal servers from .aibox-local.toml [mcp]. With current processkit releases and [ai.mcp.gateway].mode = "auto", Codex uses the processkit-gateway stdio proxy instead of one Python process per skill.

.codex/config.toml and .codex/hooks.json are gitignored — they are regenerated on every aibox apply and must not be committed.

To add MCP servers:

# aibox.toml — team-shared servers
[[ai.mcp.servers]]
name    = "github"
command = "npx"
args    = ["-y", "@modelcontextprotocol/server-github"]

# .aibox-local.toml — personal servers
[[mcp.servers]]
name    = "my-internal-tool"
command = "npx"
args    = ["-y", "@acme/internal-mcp-server"]

Installation

Codex CLI is installed via npm (npm install -g @openai/codex). To pin a specific version, set it in aibox.toml:

[ai]
harnesses = [
  { harness = "codex", enable = true, install = true, version = "0.1.0" },
]

Sandbox prerequisites

aibox images include Debian’s bubblewrap package so Codex can use the OS-provided Linux sandbox helper instead of falling back to its vendored copy. Codex still needs the container runtime and host kernel to allow unprivileged user namespaces; if namespace creation is blocked, Codex can start but sandboxed shell commands fail before the project command runs.

The preferred fix is to enable unprivileged user namespaces on the host or container runtime. Avoid privileged: true and avoid adding SYS_ADMIN to the main development container for Codex; those grants are broader than Codex’s bubblewrap sandbox requires. When Codex is selected, generated docker-compose.yml includes a narrow security_opt: seccomp=unconfined fallback because Docker/Podman seccomp profiles can block bubblewrap before the project command runs:

services:
  <container-name>:
    security_opt:
      - seccomp=unconfined

This does not grant privileged or SYS_ADMIN; it only relaxes the runtime syscall filter enough for user-namespace creation. Keep Codex in workspace-write with approvals.

aibox doctor checks the Codex sandbox posture when Codex is selected. It verifies that bwrap/bubblewrap is available, runs a user-namespace smoke probe that matches Codex’s sandbox requirement, warns if the generated service is missing Compose init: true, and warns if the main aibox service uses broad grants such as privileged: true or SYS_ADMIN.

See OpenAI’s Codex sandbox prerequisites for the upstream requirements.

6 - Copilot (GitHub)

GitHub Copilot CLI

GitHub Copilot CLI is GitHub’s terminal coding agent. GA since February 2026, validated as a Dev Container feature.

Setup

[ai]
harnesses = [
  { harness = "copilot", enable = true, install = true },
]

Run aibox apply, then inside the container:

copilot /login   # Authenticate on first launch
copilot          # Launches GitHub Copilot CLI

Requirements

A GitHub Copilot subscription (Individual, Business, or Enterprise) is required.

Configuration

Copilot’s configuration is persisted in .aibox-home/.copilot/, mounted at /home/aibox/.copilot/.

Key files:

.copilot/config.json — Copilot settings (overridable via COPILOT_HOME)

MCP Integration

GitHub Copilot CLI reads .mcp.json (the Claude Code MCP format). aibox generates .mcp.json automatically on aibox apply, merging processkit built-in servers in processkit mode, team servers from aibox.toml [ai.mcp], and personal servers from .aibox-local.toml [mcp].

.mcp.json is gitignored — it is regenerated on every aibox apply and must not be committed.

To add MCP servers:

# aibox.toml — team-shared servers
[[ai.mcp.servers]]
name    = "github"
command = "npx"
args    = ["-y", "@modelcontextprotocol/server-github"]

# .aibox-local.toml — personal servers
[[mcp.servers]]
name    = "my-internal-tool"
command = "npx"
args    = ["-y", "@acme/internal-mcp-server"]

Installation

GitHub Copilot CLI is installed via npm (npm install -g @github/copilot).

7 - Continue

Continue CLI

Continue is an open-source, provider-agnostic coding agent CLI. Designed for headless environments and containers (Apache 2.0).

Setup

[ai]
harnesses = [
  { harness = "continue", enable = true, install = true },
]

Run aibox apply, then inside the container:

cn          # Interactive mode
cn -p "..."  # Headless/non-interactive mode (great for scripts and CI)

Note: the binary is cn, not continue.

API Key

Continue is provider-agnostic — configure the LLM you want to use:

[container.environment]
CONTINUE_API_KEY = "..."   # Generic key for headless use
# Or provider-specific:
# ANTHROPIC_API_KEY = "sk-ant-..."
# OPENAI_API_KEY = "sk-..."

Configuration

Continue’s configuration is persisted in .aibox-home/.continue/, mounted at /home/aibox/.continue/.

MCP Integration

Continue has a native MCP client with a per-server file model. aibox generates files in .continue/mcpServers/ (one file per server) automatically on aibox apply, merging processkit built-in servers in processkit mode, team servers from aibox.toml [ai.mcp], and personal servers from .aibox-local.toml [mcp].

.continue/mcpServers/ is gitignored — it is regenerated on every aibox apply and must not be committed.

To add MCP servers:

# aibox.toml — team-shared servers
[[ai.mcp.servers]]
name    = "github"
command = "npx"
args    = ["-y", "@modelcontextprotocol/server-github"]

# .aibox-local.toml — personal servers
[[mcp.servers]]
name    = "my-internal-tool"
command = "npx"
args    = ["-y", "@acme/internal-mcp-server"]

Installation

Continue CLI is installed via npm (npm install -g @continuedev/cli).