mrkeyoor.com_
Fri 16 Oct 19:50 UTC
LLM Toolsevaluationupdated 14 Oct 2026

openinterpreter review

Open Interpreter is a Rust coding agent that lets language models edit files and run commands from your terminal. It supports different providers and agent behaviors in one interface, with editor connections and configurable permissions. The original Python project now lives in a separate community-maintained fork.

+42stars / 7d
Verdict

Our Open Interpreter run installed 1 pnpm package in 15 seconds and used 170 MB, but skipped build and tests, leaving the Rust agent's operation unverified. Try it if provider choice and harness emulation solve a specific coding workflow for you, and check the changes it makes. Choose the separate community fork for the original Python API, and verify Gemini compatibility before depending on it.

We ran it

Lab card: what happened when we ran openinterpreterScreenshot of openinterpreter (openinterpreter.com)
Install✓ · 15s1 packages · 170 MB
Buildn/ano build script
Testsn/ano test script
Repo8632 files~2,014,869 lines of source · 90.8 MB · 29 CI workflows

Answers from our run

Does openinterpreter build from source?

Dependencies installed in 15 seconds (1 packages), and the project has no separate build step. We cloned commit ac1fcc8 into a clean Debian container with 3 CPUs and no project-specific setup.

Does openinterpreter have tests you can run?

Not through a standard command: the project exposes no test script or target that our harness could run.

Who should not use openinterpreter?

Applications expecting the original Python interpreter API: the README identifies this as the new Rust version and points Python users to endolith/open-interpreter.

What are the alternatives to openinterpreter?

Aider, Goose, Classic Open Interpreter. Our Open Interpreter run installed 1 pnpm package in 15 seconds and used 170 MB, but skipped build and tests, leaving the Rust agent's operation unverified.

Setup3/5Node install passed; provider setup and Rust runtime remain unchecked
Docs4/5Clear config, protocol, and permission guides; onboarding has gaps
Community4/5October push and issue activity; stars span the Python project too
Maturity3/5Useful integration surfaces; provider compatibility needs verification

Discussed on

  1. hnShow HN: Open Interpreter – CodeLlama in your terminal, executing code82 points
  2. hnOpen-interpreter: A natural language interface for computers72 points

Who it’s for

Developers comparing coding models who want to change providers and harnesses inside one terminal interface.
Teams connecting a coding agent to ACP-compatible editors or existing Codex SDK clients.
Engineers reusing AGENTS.md, shared skills, and MCP tools across agent setups.
Technical users willing to check provider behavior and review the resulting file changes.

Who it’s NOT for

Applications expecting the original Python interpreter API: the README identifies this as the new Rust version and points Python users to endolith/open-interpreter.
Local-only users expecting the welcome screen to handle their provider: issue #1942 requests a local/custom choice in the current terminal login menu.
Gemini users requiring a confirmed working configuration without a trial: issue #1928 reports rejected request fields on 0.0.45, and the matching fix in PR #1939 remains unmerged.
Operators who cannot permit the documented Linux sandbox facilities or isolate bypass mode: Linux enforcement uses Bubblewrap and kernel controls, while bypass flags remove sandboxing and approval prompts.

Setup reality

Our sandbox installed commit ac1fcc8 with pnpm in 15 seconds, adding 1 package and occupying 170 MB. The 2026-10-12 run used lab-node:22 with 3 CPUs and 8 GB of RAM. Build and tests were skipped because the detected Node path had no matching script or target. That is a successful package installation, with no verified Rust build or agent session.

The README's user route is a shell or PowerShell installer. Useful sessions need a configured provider and model, plus credentials for hosted services or a reachable local endpoint. Custom providers need the correct request format. TOML settings live under ~/.openinterpreter, with project settings allowed in trusted workspaces.

The root Node package is maintenance tooling inside a Rust project. Linux sandboxing uses Bubblewrap and kernel facilities, while macOS and Windows use their own enforcement paths. Local-provider onboarding has an open usability request, and Gemini has a reported compatibility error with an unmerged fix. Verify your exact provider and permission mode.

The current Open Interpreter is a Rust coding agent

Run /harness and Open Interpreter lets you change how a model receives instructions and tools while keeping the same terminal interface. That's the reason to consider this project: you want to try different coding-agent behaviors without rebuilding your workflow around each provider. The current project README describes a Rust fork of Codex. It directs users of the original Python interpreter to a separate community-maintained repository.

That distinction matters when reading our measurements. The 90.8 MB checkout contains a pnpm workspace, but the root package describes itself as repository maintenance tooling. Its commands include formatting and documentation checks. A successful Node setup gives you evidence about that part of the repository. It doesn't establish that the Rust agent starts, edits code correctly, or works with your preferred model. Existing Python integrations deserve a separate migration decision.

What happened when we ran it

Our run installed 1 package with pnpm in 15 seconds and occupied 170 MB on disk. We cloned commit ac1fcc8 on 2026-10-12 into a fresh Debian sandbox with 3 CPUs, 8 GB of RAM, and the lab-node:22 image. The container had no secrets and ran without elevated privileges. Installation succeeded. The harness found no build or test script or target for its detected Node path, so it skipped both steps.

The checkout contained 8,632 files and roughly 2,014,869 source lines. Our scan recorded 29 CI workflow files, monorepo workspaces, no Dockerfile, and no tests directory. Those last findings describe what the scan detected, rather than proving that upstream has no checks anywhere. The defensible result is a completed package installation with no build or test result. This run supplies no evidence about model response quality, sandbox enforcement, or successful coding tasks.

Provider configuration continues after the shell installer

The README gives shell installers for macOS and Linux and a PowerShell route for Windows, followed by launching i or interpreter. Durable settings live in ~/.openinterpreter/config.toml; trusted projects can carry their own configuration. A custom provider needs an endpoint, model identifier, and a compatible request format. The configuration guide recommends environment variables or credential storage for provider secrets. /debug-config helps explain which settings actually won.

Our 15-second installation had no provider credentials, so it cannot settle whether your account or endpoint works. Open issue #1942 asks for a local or custom provider choice in the initial login menu. That report concerns the current interactive terminal interface. It doesn't prove local providers are unsupported, but it gives local-only users a concrete reason to expect configuration work beyond following the welcome screen.

Harness choices still depend on provider compatibility

The selector includes Claude Code emulation, Kimi modes, Qwen Code, and a minimal mode. These change the prompt and tool surface inside Open Interpreter's own runtime. Treat the README's low-cost-model positioning as a reason to compare your actual tasks, rather than proof of cheaper completed work. A model that needs repeated corrections can consume the savings you expected. The useful comparison is whether it produces a change you can accept through your usual review process.

For Gemini users, a successful 170 MB Node setup leaves an unresolved compatibility question. Issue #1928 reports a rejected store field in requests from version 0.0.45. The matching fix in pull request #1939 remained open and unmerged when checked on October 14. That is a specific historical report, not proof that every Gemini configuration fails today. Verify your intended endpoint before adopting this as its daily client.

Permissions and shared protocols make it easier to place

The sandbox guide separates filesystem boundaries from approval prompts. Workspace-write mode restricts writes and disables network access unless enabled, while approval policy decides when execution pauses. Linux enforcement depends on Bubblewrap and kernel facilities. Bypass flags remove both controls, so a container deployment needs a deliberate policy. If you require unattended access to valuable files, a terminal that looks familiar is insufficient evidence that its permissions suit your environment.

Our unprivileged 3-CPU container didn't exercise those controls through a live agent session. The portability features are more directly inspectable: repository AGENTS.md, shared .agents/skills, and MCP let you reuse instructions and external tools. ACP exposes the agent to compatible editors through interpreter acp. The README also documents a binary override for existing Codex SDK clients. These are useful integration routes, though compatibility still needs checking against the editor and provider you actually use.

October maintenance supports a trial with a narrow task

The last push was 2026-10-11. Release rust-v0.0.56 shipped on October 7 with model-catalog updates and a shell-environment fix, while recent issue activity includes provider requests and compatibility work. GitHub listed 68,579 stars and 14 open issues and PRs combined. Those signals support active maintenance. The star count spans the project's history, however, and should not substitute for confidence in the current Rust product. Apache-2.0 licensing gives teams a permissive basis for adapting it.

Budget the 170 MB measured footprint for the Node path, then make your adoption decision around a bounded coding task with your chosen provider and permissions. Pick Aider when terminal pair programming is the main requirement, Goose when extensible agent workflows matter more than harness emulation, or endolith's community fork when you specifically need classic Python Open Interpreter. For this Rust project, inspect the changed files and command results before trusting the final message. Our skipped build and test steps leave that acceptance work with you.

Alternatives

ProjectWhat it isPick it when
Aider gh↗A terminal pair-programming tool for making changes to an existing codebase.pick this instead when your priority is a focused terminal workflow for code edits rather than switching emulated agent harnesses.
Goose gh↗An extensible AI agent that executes tasks and connects to external tools.pick this instead when extensions and broader agent workflows matter more than matching another coding harness.
Classic Open InterpreterThe community-maintained continuation of the original Python project.pick this instead when you need the classic Python interpreter interface and can evaluate the community fork separately.

Sources

  1. Open Interpreter README
  2. Root maintenance package at measured commit ac1fcc8
  3. Configuration and custom providers
  4. Sandbox modes and approval policies
  5. Local-provider onboarding request #1942
  6. Gemini request error report #1928
  7. Unmerged Gemini compatibility fix #1939
  8. Open Interpreter rust-v0.0.56 release

More llm tools reviews

IQuest-Q1 · iCode · tokenspeed · Naive-N0.5-Flash · Strata · AnyJev · the whole board →

Related reading