Open Interpreter is an open-source runtime that connects a language model to a local code execution environment, letting the model read and write files, run shell commands, and control a browser or GUI applications on your own machine. It pioneered the idea of giving an LLM a persistent REPL loop, turning natural-language instructions into runnable code that executes immediately and feeds results back to the model. The project accumulated nearly 64,000 GitHub stars after launch in September 2023 and remains one of the most-starred agentic developer tools available.
Background
Open Interpreter was created by Killian Lucas and publicly launched on September 5, 2023. Lucas announced the project on X (formerly Twitter), describing it as "an open-source Code Interpreter that runs locally" capable of summarizing PDFs, visualizing datasets, and controlling a browser from a ChatGPT-like interface in the terminal. The project gained extraordinary early momentum: within one week of open-sourcing it had accumulated more than 20,000 GitHub stars, a rate of adoption that drew widespread attention in developer and AI research communities.
The tool emerged directly in response to the limitations of OpenAI's Code Interpreter, which had launched as part of ChatGPT Plus in July 2023 but ran inside a sandboxed cloud environment with no internet access, restricted package installation, and no persistent state across sessions. Open Interpreter inverted these constraints by running entirely on the user's own machine. There is no sandbox, no session timeout, and no restriction on which packages or tools the model can call. Code executes with the same permissions as the terminal user, so the model can install dependencies, write to the file system, and reach any networked resource the machine can access.
The project is released under the Apache 2.0 license, which allows unrestricted commercial use, modification, and redistribution with no copyleft requirement. From the beginning the codebase was written in Python and designed for extensibility: custom languages, custom model backends, and custom system prompts are all first-class configuration options rather than hacks. Throughout 2024 the scope of the project expanded significantly. The team introduced a Computer API and OS mode in January 2024, briefly pursued open-source hardware with the 01 Light device, and ultimately pivoted to a free iOS and Android voice interface called the 01 App, released in September 2024. The project continues active development as an independent open-source initiative.
Key capabilities
Persistent REPL loop with streaming output
The defining technical characteristic of Open Interpreter is its execution loop. When you give the model a task, it generates code inside a markdown code block, Open Interpreter extracts and executes that code in a persistent local session, and the resulting stdout and stderr are streamed back to the model as the next message in the conversation. The model then observes the output, decides whether the task is complete or whether an adjustment is needed, and either responds or generates corrected code for the next execution round. This feedback loop continues autonomously until the task is resolved or the model asks for human input.
Because the session is persistent, state accumulates across turns. A variable defined in one code block is available in all subsequent blocks; a file written in step one can be read in step three. This differs fundamentally from the stateless function-call model used by most coding assistants, where each tool invocation is independent. The persistent REPL gives Open Interpreter the ability to carry out genuinely multi-step workflows — pulling data from an API, processing it with pandas, writing results to a file, and then generating a visualization — all as a continuous session without the developer managing state manually.
Multi-language code execution
Open Interpreter supports Python, JavaScript, and shell (bash, zsh, and PowerShell) out of the box, and the framework accepts additional custom language runtimes through configuration. Python execution runs directly in the same Python process that hosts the interpreter, enabling deep integration with the host environment. JavaScript execution uses a Node.js subprocess. Shell execution routes through the system's default shell, giving the model direct access to system utilities, package managers, and command-line tools. The model selects which language to use for each code block based on the task at hand, and it is common for a single session to mix languages: a shell command to clone a repository, Python to analyze its contents, and another shell command to commit results.
Local model support
Open Interpreter integrates with local model providers through a combination of LiteLLM routing and a configurable API base. Supported local runtimes include Ollama, Llamafile (Mozilla's single-file model distribution format), Jan, and LM Studio. To run entirely offline, operators set interpreter.offline = True, specify a model name such as ollama/codestral, and point interpreter.llm.api_base at the local server endpoint. The interpreter --local command launches an interactive setup menu. Because local models require more explicit guidance to produce well-formed code blocks reliably, the framework includes message templating settings — user_message_template, code_output_template, and empty_code_output_template — that wrap prompts and execution output with additional context before sending to the model. These templates improve local model reliability without requiring manual prompt engineering from the user, and they reflect the project's philosophy that the interface should compensate for model limitations rather than requiring the user to do so. Running against a capable local model delivers zero API costs and complete network isolation.
Computer control mode (OS mode)
Version 0.2.0, released January 5, 2024, introduced the most significant upgrade to Open Interpreter since the initial launch. The central feature was a new Computer API that defines a standard programmatic interface between language models and the host operating system. The API exposes methods including computer.display.view() for taking screenshots, computer.mouse.click() for text-based or icon-based clicking, and computer.clipboard.view() for clipboard access. These primitives give a multimodal vision model the ability to see the screen and interact with any on-screen element, not just terminal output. The project also introduced LMC Messages, an extension of the standard chat message format that adds a "computer" role, enabling bidirectional communication between the AI assistant and the host machine.
OS mode is activated with interpreter --os. In this mode the model receives periodic screenshots of the display, issues Computer API calls to click, type, or navigate, and uses the terminal for code execution alongside direct GUI interaction. The system attempts the most efficient path for each action — for example, using Spotlight on macOS to open applications quickly rather than navigating through Finder. Practical applications include web research in a browser, filling forms in desktop applications, and orchestrating multi-application workflows. OS mode requires screen recording permissions for the terminal application and is currently limited to single-display configurations. The project documentation describes it as experimental and under active development.
Autonomy level
Open Interpreter operates at autonomy level 4. The model plans and executes multi-step sequences of code autonomously, correcting itself based on output, but the operator typically reviews and approves before sensitive or destructive actions. It can loop through long tasks with minimal human interaction, though production use usually includes at least a confirmation step for file-modifying operations.
Strengths
- First major open-source code execution agent, establishing the persistent REPL-in-the-loop pattern now used widely across the industry
- Apache 2.0 license enables unrestricted commercial use with no copyleft requirement
- Supports local models via Ollama, Llamafile, Jan, and LM Studio for zero-cost and fully offline operation
- 100+ LLM backends through LiteLLM integration, covering every major cloud provider alongside locally hosted models
- Computer API and OS mode extend reach beyond the terminal to GUI-level computer control
- Persistent session state makes multi-step workflows substantially simpler than stateless tool-call approaches
- Streaming output provides real-time visibility into what the model is doing at each execution step
Limitations
- No built-in sandboxing: code runs directly on the host machine with the terminal user's permissions, so mistakes can modify or delete files without recovery
- Absence of sandboxing makes it unsuitable for untrusted inputs or multi-tenant environments without external isolation layers
- Local model reliability for code generation varies significantly; prompt templates compensate but cannot fully close the quality gap versus frontier cloud models
- OS mode is experimental and not uniformly reliable across all operating systems and application types, particularly on Windows where accessibility APIs differ from macOS
- Less structured than purpose-built coding agents like Cursor or GitHub Copilot Workspace for sustained software development workflows with integrated version control
- Long agentic sessions can accumulate compounding errors without human checkpoints, especially when running against local models with lower instruction-following fidelity