Open Interpreter

What it is

Open Interpreter is a coding agent that lives in your terminal. You open a project, type interpreter or i, and it reads your files, edits them and runs commands for you. This is the new Rust version, a fork of OpenAI’s Codex. The README says its focus is matching the agent setup that gets the best performance out of low-cost models. One slash command switches the agent setup to a mode shaped like Claude Code, Kimi Code, Qwen Code and others. You bring the model: a ChatGPT sign-in, an API key, a Kimi Code subscription or a local model.

1. You open a project and type i
2. It reads files, edits them and runs commands
3. A sandbox limits what a command can touch
4. An approval policy decides when it asks you first
5. interpreter resume --last picks the work up later

Who it suits

Developers who want a terminal coding agent that is not tied to one model company. People who run low-cost or open models such as Kimi K3, DeepSeek or GLM and want the prompts and tools matched to the model. Codex users, since exec, sessions, MCP, AGENTS.md and skills carry over. Skip it if you want a complete desktop or browser app: for a complete desktop, browser or headless client, the README points to Interpreter Workstation. Skip it too if you came for the original Python project, which lives on as a community-maintained fork at endolith/open-interpreter.

Where to use it

Open Interpreter runs in a terminal on macOS, Linux and Windows, and WSL is supported too. Editors reach it over the Agent Client Protocol. Automation reaches it through interpreter exec.

• A modern macOS version and a recent 64-bit Linux
• Windows, installed from PowerShell, or inside WSL
• Zed, as a custom agent server with native ACP support
• JetBrains IDEs, through AI Assistant’s ACP agents
• VS Code, through a community ACP client, since VS Code has no native ACP support
• GitHub Actions, as a step that runs interpreter exec
• Apps built on OpenAI’s Codex SDK, with a one-line binary override

How to set it up

Get it saves a zip of Mindket’s setup notes in your downloads folder. It holds the maker’s steps for ChatGPT sign-in, API keys, Kimi K3, DeepSeek, GLM and local models, and for the Zed, JetBrains and VS Code editors. You install with one line, and the first run walks you through choosing a model.

1. Run the installer line for your system.
2. Restart your shell and run interpreter --version to check it.
3. Open a project and type i.
4. Choose how to sign in, or which provider to use. The /model command changes it later.
5. Ask for a concrete change.

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

On Windows, run this in PowerShell instead:

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

Then restart your shell and start a session in a project:

interpreter --version
cd my-project
i

How to use it

Type a concrete request and review the diff before it lands. In the default local workflow, the agent works inside the current workspace and asks before actions that need more access. Slash commands do the rest.

One more command switches the active mode: the prompt and tools the model sees, shaped like another agent or like Open Interpreter’s own. It lists these modes:

> /harness

native
claude-code
claude-code-bare
zcode
kimi-code
kimi-cli
qwen-code
deepseek-tui
swe-agent
minimal

Example

You have a Kimi Code subscription and an app that needs testing. You install Open Interpreter, type i in the project, choose Kimi For Coding, sign in in your browser and choose Kimi K3. Then you type the prompt from the Kimi K3 page:

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

The page says K3 can use the bundled QA skill to drive a web app in a real browser with agent-browser. The sandbox and approval settings still apply, and the page says to review actions that touch accounts or outside systems.

For newcomers and experts

If you are new. A coding agent works on your project from a request in plain words. It reads the code, edits files and runs commands. Two settings keep it in check. The sandbox decides what a command can touch. The approval policy decides when the agent stops to ask you. If you are unsure, the Sandbox page says to start with workspace-write and on-request. Try it in a small project first, and type /permissions to see where you stand.

For experts. A mode changes the prompt, tool schema, message conversion and response handling the model sees. The native Rust runtime still runs the tool calls, and the docs say it does not start the other agent’s own CLI. Routing is strict. A provider’s wire_api must fit the mode, and its value is responses, chat or messages.

With no mode set, Open Interpreter may infer one from the provider and model family. Claude models and Messages providers get claude-code. Kimi and Moonshot get kimi-code, Qwen gets qwen-code and DeepSeek gets claude-code-bare. An explicit setting always wins. This config pins the Kimi K3 route through a Moonshot key:

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"

Settings stack from the built-in defaults up to managed config, user config, trusted project config, the selected profile and, last, command-line overrides from -c, --enable, --disable or dedicated flags. The /debug-config command shows the values in effect and where each came from. Skills live in .agents/skills/ or ~/.agents/skills/, which other compatible agents can use too, so they need no copy. MCP servers go under [mcp_servers], and one command writes the entry:

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

Moving over from Codex, the Migrate page says to inspect both ~/.codex/ and ~/.openinterpreter/, and to prefer signing in again or using environment variables over copying secrets.

Good to know

It runs commands for you, so the guardrails matter.

• Permissions: the sandbox and the approval policy are the guardrails. The --yolo flag removes both, and the docs say to use it only inside an external sandbox such as a throwaway VM or isolated container
• Windows: native sandboxing enforces differently from macOS and Linux. The docs suggest WSL when you want Linux-style sandbox behavior
• Installer: the one-line installers download and run a script from the maker’s site
• Keys: API keys are usually read from environment variables. With file credential storage, treat auth.json like a password
• Model traffic: requests go to the provider you choose. The docs say local runners keep model traffic on your machine
• Updates: standalone installs can check for updates at startup. Set check_for_update_on_startup = false to turn that off
• Usage data: the docs pages behind these notes say nothing about telemetry, and Mindket’s notes do not know whether it sends any
• Local models: the server’s context window must hold the whole agent prompt and the tool schemas. If it cuts them short, a model can print a tool call as text instead of running it
• Exit codes: a zero status from interpreter exec does not prove the task’s result exists. Add --verify, and still check the files yourself
• Removal: the docs give commands that remove the install and keep ~/.openinterpreter. Deleting that folder erases config, sessions, logs and file-stored credentials, and cannot be undone. It does not remove credentials kept in an OS keyring or environment variables
• License: Apache-2.0. The LICENSE closing notice reads “Copyright 2025 OpenAI”. The Project License page says the Codex name and trademark belong to OpenAI and are not licensed by this project