### Install and Launch Open Interpreter

Source: https://www.openinterpreter.com/docs/terminal/kimi-k3

Commands to install the CLI and start the terminal UI on Unix-like systems or Windows.

```bash
curl -fsSL https://www.openinterpreter.com/install | sh
cd my-project
i
```

```powershell
irm https://www.openinterpreter.com/install.ps1 | iex
```

--------------------------------

### Initialize Compatible Provider

Source: https://www.openinterpreter.com/docs/terminal/authentication

Sets the required environment variable and starts the interpreter after configuration.

```bash
export ACME_API_KEY=...
interpreter
```

--------------------------------

### Launch local providers

Source: https://www.openinterpreter.com/docs/terminal/models

Commands to start Open Interpreter with specific local providers.

```bash
interpreter --oss --local-provider ollama
interpreter --oss --local-provider lmstudio
```

--------------------------------

### Start Open Interpreter with DeepSeek

Source: https://www.openinterpreter.com/docs/terminal/deepseek

Export the API key and launch the interpreter session.

```bash
export DEEPSEEK_API_KEY="..."
interpreter
```

--------------------------------

### Start Kimi K3 with Kimi Code Subscription

Source: https://www.openinterpreter.com/docs/terminal/kimi-k3

Launch Open Interpreter using a Kimi Code API key.

```bash
KIMI_API_KEY="..." interpreter \
  -c 'model_provider="kimi-for-coding"' \
  -m k3
```

--------------------------------

### Install Open Interpreter on Windows

Source: https://www.openinterpreter.com/docs/terminal/windows

Run this command in PowerShell to install the Open Interpreter CLI.

```powershell
irm https://www.openinterpreter.com/install.ps1 | iex
```

--------------------------------

### Verify Open Interpreter Installation

Source: https://www.openinterpreter.com/docs/terminal/install

Check the installed version to ensure the binary is correctly configured in your shell path.

```bash
interpreter --version
```

--------------------------------

### Start the terminal UI

Source: https://www.openinterpreter.com/docs/terminal/interactive

Commands to navigate to a project directory and launch the interactive interpreter.

```bash
cd my-project
interpreter
```

--------------------------------

### Install Open Interpreter via CLI

Source: https://www.openinterpreter.com/docs/terminal/install

Use these commands to download and install the managed standalone version of Open Interpreter.

```bash
curl -fsSL https://www.openinterpreter.com/install | sh
```

```powershell
irm https://www.openinterpreter.com/install.ps1 | iex
```

--------------------------------

### Start a Local App Server

Source: https://www.openinterpreter.com/docs/terminal/app-server

Launch the server using either stdio for child processes or WebSockets for external client connections.

```bash
interpreter app-server --listen stdio://
```

```bash
interpreter app-server --listen ws://127.0.0.1:9000
```

--------------------------------

### Initialize a Project Session

Source: https://www.openinterpreter.com/docs/terminal/quickstart

Commands to navigate to a project directory and start an interactive interpreter session.

```bash
cd my-project
i
```

--------------------------------

### Hook Matcher Examples

Source: https://www.openinterpreter.com/docs/terminal/hooks

Examples of regular expression matchers for various events.

```text
Bash
^apply_patch$
Edit|Write
mcp__filesystem__read_file
startup|resume
manual|auto
```

--------------------------------

### Example AGENTS.md Content

Source: https://www.openinterpreter.com/docs/terminal/agents_md

A sample structure for an AGENTS.md file defining project commands, conventions, and cautions.

```markdown
# Project Instructions

## Commands
- `pnpm test` runs unit tests.
- `pnpm lint` must pass before final changes.
- Use `pnpm typecheck` after editing TypeScript types.

## Conventions
- Keep server code under `src/server`.
- Keep UI components small and colocated with their tests.
- Prefer existing helpers in `src/lib`.

## Cautions
- Do not edit generated files under `src/generated`.
- Ask before changing database migrations.
```

--------------------------------

### Start Kimi K3 with Moonshot Platform API

Source: https://www.openinterpreter.com/docs/terminal/kimi-k3

Launch Open Interpreter or execute a single task using a Moonshot Platform API key.

```bash
MOONSHOT_API_KEY="..." interpreter \
  -c 'model_provider="moonshotai"' \
  -m kimi-k3
```

```bash
MOONSHOT_API_KEY="..." interpreter exec \
  -c 'model_provider="moonshotai"' \
  -m kimi-k3 \
  "Review this repository and fix the highest-impact bug."
```

--------------------------------

### Update CLI

Source: https://www.openinterpreter.com/docs/terminal/cli-reference

Command to trigger the configured installer for the latest release.

```bash
interpreter update
```

--------------------------------

### Install Open Interpreter on WSL

Source: https://www.openinterpreter.com/docs/terminal/windows

Use this command within a WSL environment to install the CLI using Linux tooling.

```bash
curl -fsSL https://www.openinterpreter.com/install | sh
```

--------------------------------

### CI/CD integration pattern

Source: https://www.openinterpreter.com/docs/terminal/exec

Example of running a review in a CI environment with read-only sandbox mode.

```yaml
- name: Review patch
  env:
    OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
  run: |
    interpreter exec --json --sandbox read-only \
      "review this pull request diff for regressions" \
      < pr.diff > review.jsonl
```

--------------------------------

### Initialize AGENTS.md

Source: https://www.openinterpreter.com/docs/terminal/agents_md

Use the /init command within the TUI to generate a starting AGENTS.md file based on repository inspection.

```text
/init
```

--------------------------------

### Configure Command-Backed Authentication

Source: https://www.openinterpreter.com/docs/terminal/providers

Example configuration for a provider that uses a local command to retrieve and cache a bearer token.

```toml
[model_providers.example.auth]
command = "example-token"
args = ["print"]
timeout_ms = 5000
refresh_interval_ms = 300000
```

--------------------------------

### Define Execution Policy Rules

Source: https://www.openinterpreter.com/docs/terminal/execpolicy

Example configuration for defining command matching patterns and their corresponding actions in config.toml.

```toml
[[execpolicy.rules]]
match = "ls"
action = "safe"

[[execpolicy.rules]]
match = "rm *"
action = "unsafe"

[[execpolicy.rules]]
match = "rm -rf /"
action = "forbid"
```

--------------------------------

### Basic GitHub Action Workflow

Source: https://www.openinterpreter.com/docs/terminal/github-action

A standard workflow configuration to install Open Interpreter and execute a review task on pull requests.

```yaml
name: Open Interpreter Review

on:
  pull_request:

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: read
    steps:
      - uses: actions/checkout@v4

      - name: Install Open Interpreter
        run: curl -fsSL https://www.openinterpreter.com/install | sh

      - name: Review the patch
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        run: |
          git diff origin/${{ github.base_ref }}...HEAD |
            interpreter exec --sandbox read-only \
              "Review this pull request diff for bugs, regressions, and missing tests."
```

--------------------------------

### Request Computer Use Task

Source: https://www.openinterpreter.com/docs/terminal/kimi-k3

Example prompt for triggering computer use capabilities like browser or desktop app testing.

```text
Run this app, test the sign-in flow like a user, and fix anything that breaks.
```

--------------------------------

### Provider Configuration

Source: https://www.openinterpreter.com/docs/terminal/github-action

Environment variable setup for OpenAI and custom provider configurations for alternative models.

```yaml
env:
  OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
```

```yaml
- name: Run with Kimi
  env:
    MOONSHOT_API_KEY: ${{ secrets.MOONSHOT_API_KEY }}
  run: |
    interpreter exec \
      -c 'model_provider="moonshotai"' \
      -c 'harness="kimi-code"' \
      -m kimi-k3 \
      "Summarize the risky parts of this change."
```

--------------------------------

### Start the ACP Agent

Source: https://www.openinterpreter.com/docs/terminal/acp

Command to initiate the Open Interpreter process in ACP mode.

```bash
interpreter acp
```

--------------------------------

### Deny Tool Use via Hook

Source: https://www.openinterpreter.com/docs/terminal/hooks

Example output from a hook to deny a tool call.

```json
{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "deny",
    "permissionDecisionReason": "Blocked by repository policy."
  }
}
```

--------------------------------

### Define DeepSeek provider configuration

Source: https://www.openinterpreter.com/docs/terminal/deepseek

Manual provider definition for custom deployments or proxy setups.

```toml
model_provider = "deepseek"
model = "deepseek-v4-pro"

[model_providers.deepseek]
name = "DeepSeek"
base_url = "https://api.deepseek.com"
env_key = "DEEPSEEK_API_KEY"
wire_api = "chat"
```

--------------------------------

### Bug Fix Prompt Template

Source: https://www.openinterpreter.com/docs/terminal/prompting

Use this structured format to report bugs, including reproduction steps and constraints to guide the agent.

```text
Bug: Clicking Save shows success but does not persist the setting.
Repro:
1. npm run dev
2. Open /settings
3. Toggle Enable alerts
4. Click Save
5. Refresh; the toggle resets

Constraints:
- Do not change the API shape.
- Keep the patch minimal.
- Add a regression test if practical.

Start by reproducing, then patch, then rerun the repro and tests.
```

--------------------------------

### Initialize Open Interpreter with Z.AI

Source: https://www.openinterpreter.com/docs/terminal/zai-glm

Export the API key and launch the interpreter to manually select the provider and model.

```bash
export ZAI_API_KEY="..."
interpreter
```

--------------------------------

### Configure MCP Timeouts and Startup

Source: https://www.openinterpreter.com/docs/terminal/mcp

Set startup and tool execution timeouts, and define server requirements.

```toml
[mcp_servers.docs]
command = "docs-mcp"
startup_timeout_sec = 10
tool_timeout_sec = 60
required = true
enabled = true
```

--------------------------------

### interpreter resume

Source: https://www.openinterpreter.com/docs/terminal/cli-reference

Resumes a previously started interactive session.

```APIDOC
## interpreter resume

### Description
Resumes an interactive session by ID, the last session, or all sessions.

### Usage
`interpreter resume [SESSION_ID | --last | --all]`
```

--------------------------------

### interpreter

Source: https://www.openinterpreter.com/docs/terminal/cli-reference

Starts the interactive terminal user interface (TUI).

```APIDOC
## interpreter

### Description
Starts the app-server-backed terminal UI for interactive AI sessions.

### Usage
`interpreter [flags]`
```

--------------------------------

### Initialize Open Interpreter Session

Source: https://www.openinterpreter.com/docs/terminal

Navigate to a project directory and launch the interpreter to begin an interactive coding session.

```bash
$ cd my-project
$ interpreter
> add a /health endpoint that returns the build sha
```

--------------------------------

### Request a Code Change

Source: https://www.openinterpreter.com/docs/terminal/quickstart

Example of a natural language prompt provided to the interpreter during a session.

```text
add a /health endpoint that returns the build sha
```

--------------------------------

### Build Open Interpreter from source

Source: https://www.openinterpreter.com/docs/terminal/install

Use the provided repository script to build the release bundle for local development.

```bash
./scripts/build-interpreter-release.sh
```

--------------------------------

### Enable Plugins Configuration

Source: https://www.openinterpreter.com/docs/terminal/plugins

Add this configuration to enable experimental plugin support.

```toml
[features]
plugins = true
```

--------------------------------

### Configure Provider Authentication via Command

Source: https://www.openinterpreter.com/docs/terminal/config-reference

Use a command-line tool to handle provider authentication tokens.

```toml
[model_providers.example.auth]
command = "example-token"
args = ["print"]
refresh_interval_ms = 300000
timeout_ms = 5000
```

--------------------------------

### Run Open Interpreter with a profile

Source: https://www.openinterpreter.com/docs/terminal/example-config

Execute the interpreter using a pre-defined profile from the configuration file.

```bash
interpreter --profile review
```

--------------------------------

### Launch DeepSeek with specific model

Source: https://www.openinterpreter.com/docs/terminal/deepseek

Directly specify the provider and model during interpreter startup.

```bash
DEEPSEEK_API_KEY="..." interpreter \
  -c 'model_provider="deepseek"' \
  -m deepseek-v4-pro
```

--------------------------------

### Configuration File Paths

Source: https://www.openinterpreter.com/docs/terminal/config

Locations for user-level and project-specific configuration files.

```text
~/.openinterpreter/config.toml
```

```text
.openinterpreter/config.toml
```

--------------------------------

### Uninstall Open Interpreter

Source: https://www.openinterpreter.com/docs/terminal/install

Remove the managed standalone installation files while preserving user configuration and session data.

```bash
for name in interpreter i codex-code-mode-host; do
  path="$HOME/.local/bin/$name"
  case "$(readlink "$path" 2>/dev/null || true)" in
    "$HOME/.openinterpreter/packages/standalone/"*) rm -f "$path" ;;
  esac
done
rm -rf "$HOME/.openinterpreter/packages/standalone"
```

```powershell
$binDir = Join-Path $env:LOCALAPPDATA "Programs\Open Interpreter\bin"
$interpreterHome = Join-Path $env:USERPROFILE ".openinterpreter"
$standaloneRoot = Join-Path $interpreterHome "packages\standalone"

if (Test-Path -LiteralPath $binDir) {
    $binItem = Get-Item -LiteralPath $binDir -Force
    $binTarget = [string]$binItem.Target
    $isManagedJunction =
        ($binItem.Attributes -band [IO.FileAttributes]::ReparsePoint) -and
        $binTarget.StartsWith($standaloneRoot, [StringComparison]::OrdinalIgnoreCase)

    if (-not $isManagedJunction) {
        throw "Refusing to remove $binDir because it is not an Open Interpreter managed junction."
    }

    Remove-Item -LiteralPath $binDir -Recurse -Force
}

Remove-Item -LiteralPath $standaloneRoot -Recurse -Force -ErrorAction SilentlyContinue

$userPath = [Environment]::GetEnvironmentVariable("Path", "User")
if (-not [string]::IsNullOrWhiteSpace($userPath)) {
    $nextPath = ($userPath -split ";" | Where-Object {
        -not [string]::Equals($_.TrimEnd("\"), $binDir.TrimEnd("\"), [StringComparison]::OrdinalIgnoreCase)
    }) -join ";"
    [Environment]::SetEnvironmentVariable("Path", $nextPath, "User")
}
```

--------------------------------

### Manage MCP Configurations

Source: https://www.openinterpreter.com/docs/terminal/cli-reference

Commands to list, retrieve, add, remove, and authenticate with Model Context Protocol (MCP) servers.

```bash
interpreter mcp list
interpreter mcp get <name>
interpreter mcp add <name> -- <command...>
interpreter mcp add <name> --url https://mcp.example.com
interpreter mcp remove <name>
interpreter mcp login <name>
interpreter mcp logout <name>
```

--------------------------------

### Create Temporary Override

Source: https://www.openinterpreter.com/docs/terminal/agents_md

Create a local override file to replace global instructions during testing.

```text
~/.openinterpreter/AGENTS.override.md
```

--------------------------------

### Use planning and review commands

Source: https://www.openinterpreter.com/docs/terminal/interactive

Slash commands to initiate agent planning or code review processes.

```bash
/plan
/review
```

--------------------------------

### Configure a Stdio MCP Server

Source: https://www.openinterpreter.com/docs/terminal/mcp

Define a stdio-based MCP server in the configuration file or add it via the CLI.

```toml
[mcp_servers.linear]
command = "npx"
args = ["-y", "@linear/mcp-server"]
env = { LINEAR_API_KEY = "env:LINEAR_API_KEY" }
```

```bash
interpreter mcp add linear -- npx -y @linear/mcp-server
```

--------------------------------

### MCP Server Configuration

Source: https://www.openinterpreter.com/docs/terminal/config

Configuring Model Context Protocol servers for tool integration.

```toml
[mcp_servers.docs]
command = "npx"
args = ["-y", "@acme/docs-mcp"]
env = { ACME_TOKEN = "env:ACME_TOKEN" }
default_tools_approval_mode = "prompt"
```

```toml
[mcp_servers.search]
url = "https://mcp.example.com"
bearer_token_env_var = "MCP_TOKEN"
```

--------------------------------

### Enable Hooks

Source: https://www.openinterpreter.com/docs/terminal/hooks

Enable hooks in the configuration file.

```toml
[features]
hooks = true
```

--------------------------------

### Execute Live Search via CLI

Source: https://www.openinterpreter.com/docs/terminal/web-search

Perform a one-time live web search using the interpreter CLI command.

```bash
interpreter --search "check the current release notes and summarize changes"
```

--------------------------------

### Run with Local Providers

Source: https://www.openinterpreter.com/docs/terminal/authentication

Executes a command using a local model provider via the --oss flag.

```bash
interpreter --oss "summarize this repo with my local model"
```

--------------------------------

### Planning Refactors

Source: https://www.openinterpreter.com/docs/terminal/workflows

Use the /plan command to request a structured approach before executing code changes.

```text
/plan
Split the oversized parser module without changing public behavior.
```

--------------------------------

### Configure Pre-Tool Use Hooks

Source: https://www.openinterpreter.com/docs/terminal/config-reference

Define inline hooks to execute commands before specific tools are used.

```toml
[[hooks.PreToolUse]]
matcher = "^Bash$"

[[hooks.PreToolUse.hooks]]
type = "command"
command = "python3 .openinterpreter/hooks/pre_tool_use.py"
timeout = 30
statusMessage = "Checking command"
```

--------------------------------

### Configure MCP Environment Variables

Source: https://www.openinterpreter.com/docs/terminal/mcp

Define environment variables and headers for stdio and HTTP servers.

```toml
[mcp_servers.local]
command = "my-mcp"
args = ["--stdio"]
cwd = "/Users/me/project"
env = { TOKEN = "env:MY_TOKEN" }
env_vars = ["PATH", "HOME"]
```

```toml
[mcp_servers.remote]
url = "https://mcp.example.com"
http_headers = { "X-Client" = "open-interpreter" }
env_http_headers = { "Authorization" = "MCP_AUTH_HEADER" }
```

--------------------------------

### Launch Z.AI Coding Plan directly

Source: https://www.openinterpreter.com/docs/terminal/zai-glm

Execute the interpreter with specific environment variables and flags to target the Z.AI Coding Plan provider.

```bash
ZAI_API_KEY="..." interpreter \
  -c 'model_provider="zai-coding-plan"' \
  -m glm-5.2
```

--------------------------------

### History and Memory Settings

Source: https://www.openinterpreter.com/docs/terminal/config

Configuring session persistence and experimental memory features.

```toml
[history]
persistence = "none"
```

```toml
[features]
memories = true

[memories]
use_memories = true
generate_memories = true
```

--------------------------------

### Enable Network Access

Source: https://www.openinterpreter.com/docs/terminal/sandbox

Enable network access for the workspace-write sandbox mode in the configuration file.

```toml
[sandbox_workspace_write]
network_access = true
```

--------------------------------

### Run MCP Server

Source: https://www.openinterpreter.com/docs/terminal/cli-reference

Command to expose Open Interpreter as an MCP server over stdio.

```bash
interpreter mcp-server
```

--------------------------------

### Configure Agents

Source: https://www.openinterpreter.com/docs/terminal/config-reference

Set global agent settings and define specific agent behaviors.

```toml
[agents]
max_threads = 6
max_depth = 1
job_max_runtime_seconds = 1800

[agents.explorer]
description = "Investigate code and report findings without editing."
model_reasoning_effort = "medium"
sandbox_mode = "read-only"
```

--------------------------------

### Inspect Codex and Open Interpreter directories

Source: https://www.openinterpreter.com/docs/terminal/migrate

Compare the legacy Codex home directory with the new Open Interpreter configuration path.

```bash
~/.codex/
~/.openinterpreter/
```

--------------------------------

### Provide input via arguments or stdin

Source: https://www.openinterpreter.com/docs/terminal/exec

Pass prompts directly as arguments, read from stdin, or pipe context into the command.

```bash
interpreter exec "find one bug in src/parser.rs"
```

```bash
cat task.md | interpreter exec -
```

```bash
git diff | interpreter exec "explain this diff and flag risky changes"
```

--------------------------------

### Common Settings Configuration

Source: https://www.openinterpreter.com/docs/terminal/config

Standard settings for model selection, reasoning, sandbox security, and personality.

```toml
model = "gpt-5.1-codex"
model_provider = "openai"

# "minimal" | "low" | "medium" | "high" | "xhigh"
model_reasoning_effort = "medium"

# "auto" | "concise" | "detailed" | "none"
model_reasoning_summary = "auto"

# "read-only" | "workspace-write" | "danger-full-access"
sandbox_mode = "workspace-write"

# "untrusted" | "on-request" | "never"
approval_policy = "on-request"

# "friendly" | "pragmatic" | "none"
personality = "pragmatic"

web_search = "cached"
log_dir = "~/.openinterpreter/log"
```

--------------------------------

### Enable Memories in Configuration

Source: https://www.openinterpreter.com/docs/terminal/memories

Add these settings to your configuration file to activate memory generation and usage.

```toml
[features]
memories = true

[memories]
use_memories = true
generate_memories = true
```

--------------------------------

### Configure MCP Servers

Source: https://www.openinterpreter.com/docs/terminal/config-reference

Register an MCP server with specific tools and approval modes.

```toml
[mcp_servers.docs]
command = "docs-mcp"
args = ["--stdio"]
env = { DOCS_TOKEN = "env:DOCS_TOKEN" }
startup_timeout_sec = 10
tool_timeout_sec = 60
required = false
enabled_tools = ["search", "read"]
disabled_tools = ["delete"]
default_tools_approval_mode = "prompt"

[mcp_servers.docs.tools.search]
approval_mode = "approve"
```

--------------------------------

### Authenticate with ChatGPT

Source: https://www.openinterpreter.com/docs/terminal/authentication

Initiates the browser-based login flow for ChatGPT.

```bash
interpreter
```

--------------------------------

### Manage MCP Servers via CLI

Source: https://www.openinterpreter.com/docs/terminal/mcp

Commands for listing, retrieving, removing, and authenticating with MCP servers.

```bash
interpreter mcp list
interpreter mcp get docs
interpreter mcp remove docs
interpreter mcp login docs
interpreter mcp logout docs
```

--------------------------------

### Run Harness Mode via CLI

Source: https://www.openinterpreter.com/docs/terminal/harness

Execute a single task using a specific harness configuration via the command line interface.

```bash
interpreter -c harness='"kimi-code"' "solve this task"
```

--------------------------------

### Harness Configuration

Source: https://www.openinterpreter.com/docs/terminal/config

Setting compatibility modes to shape the agent's interaction surface.

```toml
harness = "kimi-code"
harness_guidance = true
```

--------------------------------

### Configure Sandbox Workspace Write Access

Source: https://www.openinterpreter.com/docs/terminal/config-reference

Define sandbox settings for workspace write access and directory exclusions.

```toml
[sandbox_workspace_write]
network_access = false
exclude_tmpdir_env_var = false
exclude_slash_tmp = false
writable_roots = ["/tmp/project-cache"]
```

--------------------------------

### Attach images to a prompt

Source: https://www.openinterpreter.com/docs/terminal/exec

Include image files for context using the -i flag.

```bash
interpreter exec -i screenshot.png "describe the UI problem"
```

--------------------------------

### Select Model in CLI

Source: https://www.openinterpreter.com/docs/terminal/providers

Initiate the model selection process within the Open Interpreter terminal interface.

```bash
> /model
```

--------------------------------

### Authenticate with API Keys

Source: https://www.openinterpreter.com/docs/terminal/authentication

Sets the API key as an environment variable for headless or CI environments.

```bash
export OPENAI_API_KEY=sk-...
interpreter
```

--------------------------------

### Configure Agent Settings

Source: https://www.openinterpreter.com/docs/terminal/subagents

Define global constraints for agent threads, depth, and execution timeouts.

```toml
[agents]
max_threads = 6
max_depth = 1
job_max_runtime_seconds = 1800
```

--------------------------------

### Define Permission Profiles

Source: https://www.openinterpreter.com/docs/terminal/config-reference

Set granular filesystem and network access rules for a specific profile.

```toml
default_permissions = "project-edit"

[permissions.project-edit.filesystem]
":minimal" = "read"

[permissions.project-edit.filesystem.":workspace_roots"]
"." = "write"
"**/*.env" = "deny"

[permissions.project-edit.network]
enabled = true

[permissions.project-edit.network.domains]
"api.openai.com" = "allow"
"*.github.com" = "allow"
```

--------------------------------

### Configure DeepSeek harness

Source: https://www.openinterpreter.com/docs/terminal/deepseek

Set the harness to deepseek-tui for specific prompt and tool behavior.

```text
model_provider = "deepseek"
model = "deepseek-v4-pro"
harness = "deepseek-tui"
```

--------------------------------

### Python App-Server SDK Integration

Source: https://www.openinterpreter.com/docs/terminal/sdk

Configure the AppServerConfig to launch the interpreter binary instead of the standard codex server.

```python
from codex_app_server import AppServerConfig, Codex

oi_server = AppServerConfig(
    launch_args_override=(
        "interpreter",
        "app-server",
        "--listen",
        "stdio://",
    ),
)

with Codex(config=oi_server) as codex:
    thread = codex.thread_start(
        model_provider="moonshotai",
        model="kimi-k3",
        config={"harness": "kimi-code"},
    )
    result = thread.run("Review this repo and list the first migration step.")
    print(result.final_response)
```

--------------------------------

### Set Default Sandbox Mode

Source: https://www.openinterpreter.com/docs/terminal/sandbox

Configure the default sandbox mode in the configuration file.

```toml
sandbox_mode = "workspace-write"
```

--------------------------------

### CLI Overrides and Feature Flags

Source: https://www.openinterpreter.com/docs/terminal/config

Applying configuration overrides and enabling/disabling features directly from the command line.

```bash
interpreter -c model='"gpt-5.1-codex-mini"' -c approval_policy='"never"'
```

```bash
interpreter --enable hooks --disable memories
```

--------------------------------

### Troubleshoot Command Path

Source: https://www.openinterpreter.com/docs/terminal/acp

Use an absolute path for the interpreter command if the client cannot locate the executable.

```json
{
  "command": "/usr/local/bin/interpreter",
  "args": ["acp"]
}
```

--------------------------------

### Common CLI Commands

Source: https://www.openinterpreter.com/docs/terminal/quickstart

A reference table of frequently used commands for interacting with the interpreter.

```text
i or interpreter
interpreter "explain this repo"
interpreter exec "summarize the current diff"
interpreter resume --last
/review or interpreter exec review --uncommitted
/model
/permissions
```

--------------------------------

### Set Approval Policy

Source: https://www.openinterpreter.com/docs/terminal/sandbox

Configure the default approval policy in the configuration file.

```toml
approval_policy = "on-request"
```

--------------------------------

### Configure Anthropic-style provider harness

Source: https://www.openinterpreter.com/docs/terminal/harness

Set the model provider and harness explicitly for Anthropic-style endpoints.

```python
model_provider = "anthropic"
harness = "claude-code"
```

--------------------------------

### Custom Model Provider Configuration

Source: https://www.openinterpreter.com/docs/terminal/config

Adding support for custom OpenAI-compatible model providers.

```toml
model_provider = "acme"
model = "acme-coder-large"

[model_providers.acme]
name = "Acme"
base_url = "https://api.acme.example/v1"
env_key = "ACME_API_KEY"
wire_api = "responses"
```

--------------------------------

### Override model and provider settings

Source: https://www.openinterpreter.com/docs/terminal/interactive

Specify a model or use local open-source models via command-line flags.

```bash
interpreter -m gpt-5.1-codex "review this module"
interpreter --oss "try this with my local model"
```

--------------------------------

### Configure an HTTP MCP Server

Source: https://www.openinterpreter.com/docs/terminal/mcp

Define an HTTP-based MCP server using a URL and optional bearer token environment variable.

```toml
[mcp_servers.docs]
url = "https://mcp.example.com"
bearer_token_env_var = "DOCS_MCP_TOKEN"
```

```bash
interpreter mcp add docs --url https://mcp.example.com \
  --bearer-token-env-var DOCS_MCP_TOKEN
```

--------------------------------

### Create a Minimal SKILL.md

Source: https://www.openinterpreter.com/docs/terminal/skills

The basic YAML frontmatter and instruction format required for a skill definition.

```yaml
---
name: cut-release
description: Prepare a release by testing, updating changelog, and tagging.
---

When asked to cut a release:

1. Run the test suite.
2. Update the changelog.
3. Bump the version according to semver.
4. Prepare the commit and tag, but ask before publishing.
```

--------------------------------

### Set Environment Variables for ZCode

Source: https://www.openinterpreter.com/docs/terminal/zai-glm

Export the required API key and authorization header before launching the interpreter.

```bash
export ZAI_API_KEY="..."
export ZAI_AUTHORIZATION="Bearer $ZAI_API_KEY"
interpreter
```

--------------------------------

### Plugin Directory Structure

Source: https://www.openinterpreter.com/docs/terminal/plugins

Standard directory layout for an Open Interpreter plugin.

```text
my-plugin/
├── .codex-plugin/
│   └── plugin.json
├── skills/
├── mcp/
└── hooks/
```

--------------------------------

### Configure Open Interpreter settings

Source: https://www.openinterpreter.com/docs/terminal/example-config

Place this configuration in ~/.openinterpreter/config.toml to customize model providers, sandbox environments, and feature flags.

```toml
# ---------------------------------------------------------------
# Model and provider
# ---------------------------------------------------------------

model_provider = "openai"
model = "gpt-5.1-codex"
model_reasoning_effort = "medium"
model_reasoning_summary = "auto"
personality = "pragmatic"
web_search = "cached"

# ---------------------------------------------------------------
# Harness compatibility
# ---------------------------------------------------------------

# Leave unset to choose the recommended harness for the selected provider.
# harness = "kimi-code"
harness_guidance = true

# ---------------------------------------------------------------
# Sandbox and approvals
# ---------------------------------------------------------------

sandbox_mode = "workspace-write"
approval_policy = "on-request"

[sandbox_workspace_write]
network_access = false
writable_roots = []

# ---------------------------------------------------------------
# Logging and history
# ---------------------------------------------------------------

log_dir = "~/.openinterpreter/log"

[history]
persistence = "save-all"
max_bytes = 104857600

# ---------------------------------------------------------------
# Profiles
# ---------------------------------------------------------------

[profiles.fast]
model = "gpt-5.1-codex-mini"
model_reasoning_effort = "low"

[profiles.review]
model = "gpt-5.1-codex"
model_reasoning_effort = "high"
sandbox_mode = "read-only"

# ---------------------------------------------------------------
# Custom provider
# ---------------------------------------------------------------

[model_providers.example]
name = "Example"
base_url = "https://api.example.com/v1"
env_key = "EXAMPLE_API_KEY"
wire_api = "responses"

# ---------------------------------------------------------------
# MCP servers
# ---------------------------------------------------------------

[mcp_servers.docs]
command = "docs-server"
default_tools_approval_mode = "prompt"

[mcp_servers.docs.tools.search]
approval_mode = "approve"

# ---------------------------------------------------------------
# Features
# ---------------------------------------------------------------

[features]
hooks = true
multi_agent = true
shell_tool = true
shell_snapshot = true
unified_exec = true
memories = false
apps = false
plugins = false
undo = false
```

--------------------------------

### Defining Configuration Profiles

Source: https://www.openinterpreter.com/docs/terminal/config

Named groups of settings that can be toggled via the CLI.

```toml
[profiles.fast]
model = "gpt-5.1-codex-mini"
model_reasoning_effort = "low"

[profiles.review]
model = "gpt-5.1-codex"
model_reasoning_effort = "high"
sandbox_mode = "read-only"
```

```bash
interpreter --profile review
```

--------------------------------

### Configure MCP Client

Source: https://www.openinterpreter.com/docs/terminal/mcp-server

Add this configuration to your MCP client to define the stdio command for the Open Interpreter server.

```json
{
  "mcpServers": {
    "open-interpreter": {
      "command": "interpreter",
      "args": ["mcp-server"]
    }
  }
}
```

--------------------------------

### Configure Compatible Providers

Source: https://www.openinterpreter.com/docs/terminal/authentication

Defines a custom OpenAI-compatible provider in the configuration file.

```toml
model_provider = "acme"
model = "acme-coder"

[model_providers.acme]
name = "Acme"
base_url = "https://api.acme.example/v1"
env_key = "ACME_API_KEY"
wire_api = "responses"
```

--------------------------------

### Configure a custom provider

Source: https://www.openinterpreter.com/docs/terminal/providers

Define a custom provider in the configuration file by specifying the name, base URL, environment key, and wire API type.

```toml
[model_providers.example]
name = "Example"
base_url = "https://api.example.com/v1"
env_key = "EXAMPLE_API_KEY"
wire_api = "chat"
```

--------------------------------

### Configure ZCode in config.toml

Source: https://www.openinterpreter.com/docs/terminal/zai-glm

Add the ZCode provider configuration to the Open Interpreter config file to enable the Z.AI Coding Plan endpoint.

```toml
model_provider = "zai-zcode"
model = "glm-5.2"
harness = "zcode"

[model_providers.zai-zcode]
name = "Z.AI ZCode"
base_url = "https://api.z.ai/api/anthropic"
env_key = "ZAI_API_KEY"
wire_api = "messages"
env_http_headers = { Authorization = "ZAI_AUTHORIZATION" }
```

--------------------------------

### Connect a client to the daemon

Source: https://www.openinterpreter.com/docs/terminal/daemon

Use the --remote flag to point a client to the daemon's unix socket or websocket URL.

```bash
interpreter --remote <ws-url-or-unix-socket>
```

--------------------------------

### Resume Sessions via CLI

Source: https://www.openinterpreter.com/docs/terminal/sessions

Commands to resume previous sessions, including filtering by directory or specific session ID.

```bash
interpreter resume --last
```

```bash
interpreter resume
```

```bash
interpreter resume --all
```

```bash
interpreter resume <SESSION_ID>
```

--------------------------------

### TypeScript SDK Configuration

Source: https://www.openinterpreter.com/docs/terminal/sdk

Initialize the Codex SDK with the interpreter path override and model configuration.

```typescript
import { Codex } from "@openai/codex-sdk";

const codex = new Codex({
  codexPathOverride: "interpreter",
  config: {
    model_provider: "moonshotai",
    harness: "kimi-code",
  },
});

const thread = codex.startThread({ model: "kimi-k3" });
const result = await thread.run(
  "Review this repo and list the first migration step.",
);

console.log(result);
```

--------------------------------

### Configure Open Interpreter logging

Source: https://www.openinterpreter.com/docs/terminal/install

Manage log locations and verbosity for the TUI and CLI sessions.

```text
~/.openinterpreter/log/
```

```bash
interpreter -c log_dir='"./.interpreter-log"'
```

```bash
RUST_LOG=info interpreter
```

--------------------------------

### Configure remote local provider

Source: https://www.openinterpreter.com/docs/terminal/models

Command to connect to a local provider running on a different host or port using environment variables.

```bash
CODEX_OSS_BASE_URL=http://192.168.1.20:1234/v1 \
  interpreter --oss --local-provider lmstudio -m qwen/qwen3-coder-next
```

--------------------------------

### Define Custom Permission Profile

Source: https://www.openinterpreter.com/docs/terminal/permissions

Create a custom profile with specific workspace roots, filesystem access rules, and network domain restrictions.

```toml
default_permissions = "project-edit"

[permissions.project-edit.workspace_roots]
"~/code/app" = true
"~/code/shared-lib" = true

[permissions.project-edit.filesystem]
":minimal" = "read"

[permissions.project-edit.filesystem.":workspace_roots"]
"." = "write"
".devcontainer" = "read"
"**/*.env" = "deny"

[permissions.project-edit.network]
enabled = true

[permissions.project-edit.network.domains]
"api.openai.com" = "allow"
"**.github.com" = "allow"
"tracking.example.com" = "deny"
```

--------------------------------

### Resume Previous Session

Source: https://www.openinterpreter.com/docs/terminal/quickstart

Command to restore the context and working directory of the last session.

```shell
interpreter resume --last
```

--------------------------------

### Configuration Schema Path

Source: https://www.openinterpreter.com/docs/terminal/config

Location of the JSON schema for configuration validation.

```text
codex-rs/core/config.schema.json
```

--------------------------------

### Enable Auto-Review

Source: https://www.openinterpreter.com/docs/terminal/auto-review

Set the approvals_reviewer configuration to 'auto_review' to delegate approval prompts.

```python
approvals_reviewer = "auto_review"
```

--------------------------------

### Configure model provider settings

Source: https://www.openinterpreter.com/docs/terminal/harness

Define the model provider, specific model, harness type, and provider connection details.

```toml
model_provider = "moonshotai"
model = "kimi-k3"
harness = "kimi-code"

[model_providers.moonshotai]
name = "Moonshot AI"
base_url = "https://api.moonshot.ai/v1"
env_key = "MOONSHOT_API_KEY"
wire_api = "chat"
```

--------------------------------

### Configure a Model Provider

Source: https://www.openinterpreter.com/docs/terminal/config-reference

Define a custom model provider with API details and retry logic.

```toml
[model_providers.example]
name = "Example"
base_url = "https://api.example.com/v1"
env_key = "EXAMPLE_API_KEY"
wire_api = "responses"
request_max_retries = 4
stream_max_retries = 5
stream_idle_timeout_ms = 300000
```

--------------------------------

### Execute a single task with DeepSeek

Source: https://www.openinterpreter.com/docs/terminal/deepseek

Run a non-interactive command using the DeepSeek provider.

```bash
DEEPSEEK_API_KEY="..." interpreter exec \
  -c 'model_provider="deepseek"' \
  -m deepseek-v4-pro \
  "Review this repository and fix the highest-impact bug."
```

--------------------------------

### Set MCP Approval Modes

Source: https://www.openinterpreter.com/docs/terminal/mcp

Configure default approval modes for a server or override settings for specific tools.

```toml
[mcp_servers.docs]
command = "docs-mcp"
default_tools_approval_mode = "prompt"
```

```toml
[mcp_servers.docs.tools.search]
approval_mode = "approve"
```

--------------------------------

### Regenerate Provider and Model Catalogs

Source: https://www.openinterpreter.com/docs/terminal/providers

Run these scripts from the codex-rs directory to update the provider and model compatibility catalogs when source data changes.

```bash
python3 scripts/write_provider_catalog.py
python3 scripts/write_model_compatibility_catalog.py
```

--------------------------------

### Configure Web Search Modes

Source: https://www.openinterpreter.com/docs/terminal/web-search

Set the web search behavior by assigning one of the three available modes to the web_search variable.

```python
web_search = "cached"   # default-style search behavior
web_search = "live"     # request live browsing
web_search = "disabled" # no web search tool
```

--------------------------------

### CI Execution Command

Source: https://www.openinterpreter.com/docs/terminal/sdk

Run a single task using the interpreter exec command for CI environments.

```bash
interpreter exec \
  -c 'model_provider="moonshotai"' \
  -c 'harness="kimi-code"' \
  -m "kimi-k3" \
  "Review this pull request and report blocking issues."
```

--------------------------------

### Override Models via CLI

Source: https://www.openinterpreter.com/docs/terminal/models

Use command-line flags to specify a model or provider for a single execution.

```bash
interpreter -m gpt-5.1-codex "review this module"
interpreter --oss "use my local open source provider"
```

--------------------------------

### Configure ACP Agent Servers

Source: https://www.openinterpreter.com/docs/terminal/acp

JSON configuration structures for integrating Open Interpreter into various IDEs and ACP-compatible clients.

```json
{
  "agent_servers": {
    "Open Interpreter": {
      "type": "custom",
      "command": "interpreter",
      "args": ["acp"],
      "env": {
        "INTERPRETER_HOME": "/Users/you/.openinterpreter"
      }
    }
  }
}
```

```json
{
  "default_mcp_settings": {
    "use_idea_mcp": true,
    "use_custom_mcp": true
  },
  "agent_servers": {
    "Open Interpreter": {
      "command": "interpreter",
      "args": ["acp"],
      "env": {
        "INTERPRETER_HOME": "/Users/you/.openinterpreter"
      }
    }
  }
}
```

```json
{
  "agent_servers": {
    "Open Interpreter": {
      "command": "interpreter",
      "args": ["acp"],
      "env": {
        "INTERPRETER_HOME": "/Users/you/.openinterpreter"
      }
    }
  }
}
```

--------------------------------

### Enable Network Access

Source: https://www.openinterpreter.com/docs/terminal/permissions

Explicitly enable network access within a custom permission profile.

```toml
[permissions.project-edit.network]
enabled = true
```

--------------------------------

### Enable Multi-Agent Feature

Source: https://www.openinterpreter.com/docs/terminal/subagents

Add this configuration to enable the multi-agent functionality in your build.

```toml
[features]
multi_agent = true
```

--------------------------------

### Attach images to interpreter commands

Source: https://www.openinterpreter.com/docs/terminal/models

Use the -i flag to include image files in your interpreter request.

```bash
interpreter -i screenshot.png "what is wrong here?"
```

--------------------------------

### Configure Fast Mode Profile

Source: https://www.openinterpreter.com/docs/terminal/speed

Set the reasoning effort to low within a profile to enable faster model responses.

```toml
[profiles.fast]
model_reasoning_effort = "low"
```

--------------------------------

### Configure Trusted Commands

Source: https://www.openinterpreter.com/docs/terminal/execpolicy

Set specific commands to safe to bypass approval prompts.

```toml
[[execpolicy.rules]]
match = "pnpm test*"
action = "safe"

[[execpolicy.rules]]
match = "pnpm lint*"
action = "safe"
```

--------------------------------

### Manage the Open Interpreter daemon

Source: https://www.openinterpreter.com/docs/terminal/daemon

Commands to control the lifecycle of the background daemon process.

```bash
interpreter app-server daemon start
interpreter app-server daemon restart
interpreter app-server daemon stop
interpreter app-server daemon version
```

--------------------------------

### Set Model Configuration Defaults

Source: https://www.openinterpreter.com/docs/terminal/models

Define persistent model settings in the configuration file.

```toml
model_provider = "openai"
model = "gpt-5.1-codex"
model_reasoning_effort = "medium"
model_reasoning_summary = "auto"
model_verbosity = "medium"
```

--------------------------------

### Configure Environment Variables

Source: https://www.openinterpreter.com/docs/terminal/acp

Common environment variables for configuring the ACP agent's home directory and provider API keys.

```bash
INTERPRETER_HOME="$HOME/.openinterpreter"
OPENAI_API_KEY="..."
ANTHROPIC_API_KEY="..."
KIMI_API_KEY="..."
MOONSHOT_API_KEY="..."
```

--------------------------------

### Configure Credential Storage

Source: https://www.openinterpreter.com/docs/terminal/authentication

Sets the storage mechanism for user credentials in the configuration.

```toml
cli_auth_credentials_store = "auto" # "auto" | "keyring" | "file"
```