Open Interpreter

Executes arbitrary code (Python, JavaScript, shell, etc.) in a sandboxed local environment controlled by an LLM agent. The system uses a stateful conversation loop where the LLM receives execution results and decides next steps, enabling multi-step reasoning and iterative problem-solving without sending code to external services. Implements a request-response cycle where code is generated, executed locally, and results fed back to the model for refinement.

Generates executable code across Python, JavaScript, shell, and other languages by maintaining awareness of the execution environment's state and available system tools. The LLM receives structured context about installed packages, file system state, and previous execution results, enabling it to generate code that accounts for what's already available rather than generating redundant setup. Uses a context-injection pattern where environment metadata is prepended to prompts.

Streams code execution output and LLM responses in real-time to the user interface, providing immediate feedback rather than waiting for complete execution. Implements streaming at two levels: LLM token streaming (showing generated code as it's produced) and execution output streaming (showing command output line-by-line). Enables users to monitor long-running operations and interrupt if needed.

Exports Open Interpreter sessions to Jupyter notebooks (.ipynb format) with full cell history, outputs, and metadata. Enables users to save interactive sessions as reproducible notebooks for sharing, documentation, or further refinement in Jupyter. Supports importing notebooks as starting context for new sessions. Preserves execution order, cell outputs, and markdown explanations.

Provides a conversational interface (CLI or Jupyter-like) where users issue natural language commands and receive immediate code execution results in a single session. Implements a stateful conversation loop maintaining message history, execution context, and variable state across turns. The LLM can reference previous results, ask clarifying questions, and refine its approach based on feedback without losing context.

Abstracts LLM interactions behind a provider-agnostic interface supporting OpenAI, Anthropic, Ollama, and other compatible APIs. Uses a strategy pattern where different LLM backends implement a common interface for message passing and token counting. Allows users to swap providers without changing application code, enabling cost optimization, latency tuning, or compliance with provider restrictions.

Executes generated code in isolated subprocess environments with captured stdout/stderr, timeout enforcement, and error recovery. Implements process-level isolation using Python's subprocess module with configurable resource limits. Captures execution output, exceptions, and system state changes, returning structured results to the LLM for analysis. Handles timeouts, crashes, and permission errors gracefully without terminating the main session.

Enables code to read, write, and manipulate files through generated code while maintaining awareness of the working directory and file structure. Provides helper functions for common file operations (read, write, list, delete) that are injected into the execution context. Resolves relative paths against the current working directory, allowing code to reference files created in previous steps without absolute path knowledge.

Automatically installs missing Python packages and system dependencies when code execution fails due to import errors. Detects ImportError exceptions, parses the missing module name, and invokes pip install or system package managers (apt, brew, etc.) to resolve dependencies. Retries code execution after installation, enabling the LLM to generate code that uses any available package without pre-installation.

Enables code to process images by generating Python code using libraries like PIL, OpenCV, or matplotlib. The LLM can analyze image paths, generate image manipulation code, and display results. Supports reading image files, applying transformations (resize, crop, filter), and generating visualizations. Works by executing image processing code in the local environment and capturing output files or display results.

Generates and executes shell commands (bash, PowerShell, etc.) through code, enabling system-level operations like file management, process control, and system queries. Captures command output and error streams, allowing the LLM to parse results and make decisions based on system state. Supports environment variable passing and working directory context.

Implements an error-feedback loop where execution failures (exceptions, timeouts, incorrect output) are captured and returned to the LLM with full context. The LLM analyzes the error, generates corrected code, and retries automatically. Maintains error history to avoid repeating the same mistakes. Supports user feedback ('that's not what I wanted') to guide refinement without requiring code rewriting.