Key Takeaways
- License changed from AGPL 3.0 to Apache 2.0 — confirmed via the GitHub API and the repository's LICENSE file
- Rewritten from scratch in Rust as a fork of OpenAI's open-source Codex project
- Current GitHub description: "A coding agent for open models like Kimi K3"
- Named model integration targets: Kimi K3, DeepSeek, Qwen, GLM/Z.AI
- 68,227 stars, 5,871 forks, only 10 open issues, last pushed 2026-08-20
- Became the #1 trending Rust repository on GitHub after shipping its Kimi K3 harness
- The original Python/AGPL "control your computer" tool lives on as a community fork at endolith/open-interpreter
📍 In One Sentence
Open Interpreter is now a Rust-based, Apache 2.0-licensed coding agent forked from OpenAI's open-source Codex and built to run open models like Kimi K3, replacing its original Python/AGPL "let a model run code on your machine" design.
💬 In Plain Terms
The tool used to be a way to let ChatGPT-style code execution run locally instead of in OpenAI's cloud sandbox. It still does something similar in spirit, but the code, the license, and the target audience — people running open models, not one vendor's API — have all changed.
📌Note: This review covers the current Rust/Codex-fork version of Open Interpreter. If you are looking for the original 2023-era Python tool that browses the web and edits files with natural-language commands, that lives on in the community fork, not the main repository.
What Is Open Interpreter in 2026?
Open Interpreter (github.com/openinterpreter/openinterpreter, commonly linked as github.com/OpenInterpreter/open-interpreter, which redirects to the canonical lowercase org) is a terminal-based coding agent. Its current GitHub description states it plainly: "A coding agent for open models like Kimi K3." That is a different project, in a different language, under a different license, than the tool that made the name known in 2023.
- Rust core, replacing the original Python codebase entirely
- Forked from OpenAI's open-source Codex project, and compatible with the Agent Client Protocol (ACP)
- Reimplements the provider-recommended "Kimi Code" harness in Rust, tuned for getting more out of open and low-cost models rather than one hosted API
- Repository topics on GitHub include acp, coding-agent, deepseek, kimi, qwen, and rust
- Homepage: openinterpreter.com
- Founded by Killian Lucas, who leads Open Interpreter Inc. as CEO and lead developer
From a 2023 AGPL Side Project to a 2026 Rust Rewrite
The Open Interpreter repository was created on 2023-07-14 and launched publicly in September 2023, at the height of interest in giving language models direct access to a terminal. Its founder, Killian Lucas — based in Bellingham, Washington — built it to give people the same "let the model just run the code" capability as OpenAI's hosted Code Interpreter, but running locally or against a remote model of the user's choice instead of inside a restricted cloud sandbox: no internet-access limits, no file-size caps, and full control over the execution environment. Lucas went on to found Open Interpreter Inc., where he is CEO and lead developer.
That original tool was released under the AGPL 3.0 license and described itself as a natural-language interface letting an LLM edit files, browse the web, and analyze datasets from a chat-style terminal session — closer to a general-purpose computer-control agent than a coding-specific tool.
By 2026, the project had shifted direction entirely. The team rewrote the codebase from scratch in Rust, forked it from OpenAI's own open-source Codex project, and repositioned it as a coding agent purpose-built for open and low-cost models rather than a general "control your computer" assistant. The license changed from AGPL 3.0 to Apache 2.0 in the same period.
Why it existed in 2023
OpenAI's hosted Code Interpreter ran inside a restricted cloud sandbox — limited internet access, capped file sizes, and no control over the execution environment. Open Interpreter's founding motivation was to give people that same capability locally or against a model of their choice, without those restrictions.
What changed by 2026
The project rewrote its core in Rust, forked from OpenAI's Codex, and narrowed its focus to being a coding agent for open models — a different scope than the original general-purpose "control your computer" tool.
How Open Interpreter Works Now
Open Interpreter's current architecture is a Rust reimplementation of the provider-recommended "Kimi Code" harness, wrapped in a Codex-compatible terminal interface. It speaks the Agent Client Protocol (ACP), which lets it plug into ACP-compatible editors and tools rather than only working as a standalone CLI.
- Rust core for the agent loop and terminal interface
- Forked from and structurally compatible with OpenAI's open-source Codex CLI
- ACP (Agent Client Protocol) compatible, so it can integrate with other ACP-aware tools, not just run standalone
- Named integration targets: Kimi K3, DeepSeek, Qwen, and GLM/Z.AI
- Still ships a Python SDK and runtime component alongside the Rust core (see the python-runtime-build.yml and python-sdk-release.yml workflows), so it is not a Rust-only project end to end
- 1macOS or Linux: run
curl -fsSL https://www.openinterpreter.com/install | shin a terminal. - 2Windows: run `irm www.openinterpreter.com/install.ps1 | iex` in PowerShell.
- 3Start the agent by running
iorinterpreterfrom a terminal. - 4Point it at an open model such as Kimi K3, DeepSeek, Qwen, or GLM/Z.AI per that provider's setup instructions — the project does not document a single required backend.
- 5Use it from the terminal directly, or connect it through an ACP-compatible editor if you prefer working inside an IDE rather than a standalone CLI.
The License Change: AGPL 3.0 to Apache 2.0
Open Interpreter's original Python-era codebase was released under AGPL 3.0, a copyleft license that requires anyone who modifies the code and runs it as a network service to release their modified source. The current Rust codebase is released under Apache 2.0, confirmed via both the GitHub API's license field and the raw LICENSE file at the repository root.
What Apache 2.0 permits that AGPL 3.0 did not
Apache 2.0 is a permissive license: you can use, modify, and redistribute the code — including inside a closed-source commercial product — without an obligation to release your source code or the source of any service you build on top of it. AGPL 3.0's copyleft "network use" clause imposed exactly that obligation on anyone who ran a modified version as a hosted service.
What stays the same
Apache 2.0 still requires you to preserve copyright and license notices and to state significant changes you make to the code. It also includes an explicit patent grant, which AGPL 3.0 does not.
Is Open Interpreter Still Maintained?
Every signal available on the repository points to active, current maintenance rather than a project coasting on past popularity. It was last pushed to on 2026-08-20 — within roughly two weeks of this review — and carries only 10 open issues against 68,227 stars and 5,871 forks, a low ratio for a repository this size.
The project also runs a substantial automated CI setup, evidenced by the workflow files in its .github/workflows/ directory: rust-ci.yml, rust-ci-full.yml, and rust-ci-full-nextest-platform.yml run the Rust test suite via cargo nextest across multiple OS platforms; cargo-ci.yml and cargo-deny.yml cover dependency and security auditing; blocking-ci.yml is a required check that gates merges; postmerge-ci.yml and public-ci.yml run further validation; python-runtime-build.yml and python-sdk-release.yml build and release the Python SDK component; and repo-checks.yml plus codespell.yml handle repository hygiene.
Repository activity
- What it shows:
- Last pushed 2026-08-20, not archived
Star-to-issue ratio
- What it shows:
- 68,227 stars vs. 10 open issues — a small backlog
Fork count
- What it shows:
- 5,871 forks
CI coverage
- What it shows:
- 9+ workflow files covering Rust tests, dependency audits, and required merge gates
Trending status
- What it shows:
- #1 trending Rust repository on GitHub after the Kimi K3 harness shipped
📌Note: We did not run our own test suite against Open Interpreter for this review. The maintenance signals above are drawn from the repository's public commit history, issue count, and its own published CI workflow files, not from benchmarks PromptQuorum generated. Verify current status directly on the repository before committing significant time to it.
Who Should Use Open Interpreter?
The right fit depends on whether you specifically want a coding agent tuned for open models, or the original general-purpose "control your computer" tool.
Use Open Interpreter (current, Rust) if
- You want a Codex-compatible terminal coding agent tuned for open or low-cost models like Kimi K3, DeepSeek, Qwen, or GLM/Z.AI
- You already use, or plan to use, an ACP-compatible editor and want an agent that speaks that protocol
- You want a permissively licensed (Apache 2.0) agent you can build on commercially without a copyleft obligation
Use the community endolith/open-interpreter fork if
- You specifically want the original 2023-era Python tool that lets a model browse the web, edit files, and analyze datasets from a general chat-style terminal session, not a coding-specific agent
- You need the AGPL 3.0-licensed codebase for a reason tied to that specific license
Consider a different tool entirely if
- You want a proprietary, vendor-hosted coding agent — OpenAI Codex CLI or Anthropic Claude Code are the closest closed-source equivalents to what Open Interpreter's current architecture is modeled on
- You want an IDE-native autonomous agent rather than a terminal-first one — Cline or OpenHands are built around that workflow
- You want the unscoped, general-purpose autonomous-agent pattern Open Interpreter originally competed in — AutoGPT and BabyAGI (both reviewed on this site) are the direct historical peers of that category
Open Interpreter vs. Alternatives
Open Interpreter's current positioning — a Codex-compatible terminal coding agent for open models — puts it alongside several categories of tool: other terminal coding agents, IDE-native agents, proprietary vendor agents, and its own historical peers from the 2023 "give an LLM agency over your machine" wave.
Best Choice by Use Case
- Best for open-model coding agents: Open Interpreter — purpose-built for Kimi K3, DeepSeek, Qwen, and GLM/Z.AI
- Best for git-native diff review: Aider — commits are structured as reviewable git diffs
- Best for staying inside VS Code: Cline — runs as an extension rather than a separate terminal tool
- Best for a proprietary, vendor-supported option: OpenAI Codex CLI or Claude Code
- Best for revisiting the original unscoped-agent pattern: AutoGPT (classic) or BabyAGI, both reviewed on this site
Tool | Interface | License | Best For |
|---|---|---|---|
| Open Interpreter | Terminal, ACP-compatible | Apache 2.0 | Coding agent for open models |
| Aider | Terminal | Apache 2.0 | Git-native diff-based pair programming |
| Cline | VS Code extension | Apache 2.0 | Autonomous IDE agent |
| OpenHands | Sandboxed agent runtime | MIT | Autonomous SWE agent tasks |
| Continue.dev | IDE extension | Apache 2.0 | Autocomplete + chat, IDE-scoped |
| OpenAI Codex CLI | Terminal | Proprietary | Vendor-hosted terminal coding agent |
| Claude Code | Terminal | Proprietary | Vendor-hosted terminal coding agent |
| AutoGPT (classic) | CLI, autonomous loop | MIT | Unscoped autonomous-agent experiments |
| BabyAGI | CLI, autonomous loop | MIT | Minimal autonomous task-loop experiments |
Common Mistakes When Evaluating Open Interpreter
Most confusion about Open Interpreter in 2026 comes from expecting the 2023-era tool rather than the current Rust rewrite.
Mistake 1: Assuming it is still AGPL 3.0 licensed
The AGPL 3.0 license applied to the original Python-era codebase. The current Rust project is Apache 2.0 licensed — confirmed via the GitHub API and the repository's LICENSE file. Check the LICENSE file directly before assuming either license applies.
Mistake 2: Expecting the original "control your computer" tool
Open Interpreter's current description is "a coding agent for open models like Kimi K3" — a narrower, coding-specific scope than the original general-purpose file-editing and web-browsing agent. That original tool lives on in the community fork at endolith/open-interpreter, not the main repository.
Mistake 3: Treating it as a Rust-only project
The repository still ships and releases a Python SDK and runtime component (see python-runtime-build.yml and python-sdk-release.yml), alongside the Rust core. It is a Rust-core project with a Python component, not a pure rewrite that dropped Python entirely.
Mistake 4: Assuming a specific model backend is required
The project names Kimi K3, DeepSeek, Qwen, and GLM/Z.AI as integration targets, but does not document a single required backend. Which open model you point it at is a configuration choice, not a fixed dependency.
Frequently Asked Questions
What license is Open Interpreter under?
Apache 2.0, confirmed via the GitHub API's license field and the repository's LICENSE file. This is a change from the original AGPL 3.0 license used by the earlier Python-era codebase.
Is Open Interpreter still maintained?
Yes. The repository was last pushed to on 2026-08-20, carries only 10 open issues against 68,227 stars, and runs a multi-workflow CI setup covering Rust tests, dependency audits, and required merge checks.
What happened to the original Open Interpreter?
The original Python tool — which let a local or remote model edit files, browse the web, and run code from a natural-language terminal session — was rewritten from scratch in Rust in 2026 and forked from OpenAI's open-source Codex project. The original Python/AGPL version lives on as a community fork at github.com/endolith/open-interpreter.
What models does Open Interpreter support?
The project names Kimi K3, DeepSeek, Qwen, and GLM/Z.AI as integration targets in its repository topics and description, and reimplements the "Kimi Code" harness in Rust. It does not document a single required model backend.
How do I install Open Interpreter?
On macOS or Linux, run curl -fsSL https://www.openinterpreter.com/install | sh. On Windows, run irm https://www.openinterpreter.com/install.ps1 | iex in PowerShell. Then start the agent with i or interpreter.
Is Open Interpreter free to use?
Yes. It is released under the Apache 2.0 license, which permits free use, modification, and redistribution, including inside a commercial product, without an obligation to release your own source code.
Is Open Interpreter compatible with Codex or Claude Code?
Open Interpreter is a fork of OpenAI's open-source Codex project and is built to be Codex-compatible, and it supports the Agent Client Protocol (ACP) for integrating with other ACP-aware tools. It is a separate, independently maintained project from OpenAI's Codex CLI and Anthropic's Claude Code, not an official extension of either.
Does Open Interpreter still let a model control my whole computer?
The current Rust project is scoped as a coding agent, not a general "control your computer" tool. The original broader-scope Python tool — file editing, web browsing, dataset analysis — lives on separately in the community fork at endolith/open-interpreter.
How does Open Interpreter compare to Aider or Cline?
All three are terminal- or IDE-based coding agents. Aider is git-native and structures its output as reviewable diffs; Cline runs as a VS Code extension; Open Interpreter is a standalone, Codex-compatible terminal agent tuned specifically for open models. Which one fits depends on whether you want git-diff review, IDE integration, or open-model-first tuning.
Why did Open Interpreter switch from AGPL 3.0 to Apache 2.0?
The project does not publish a stated reason in its README for the specific license change alongside the 2026 rewrite. Apache 2.0 is a more permissive license than AGPL 3.0: it removes the copyleft "network use" source-disclosure obligation and adds an explicit patent grant, which makes the code easier to build commercial products on top of. Read the LICENSE file directly to confirm current terms before relying on this distinction.