DEV Community

Cover image for Open Source Project of the Day (#125): Open Interpreter — Open-Source AI Coding Agent, Rewritten in Rust, Supporting Kimi, Qwen, and DeepSeek
WonderLab
WonderLab

Posted on

Open Source Project of the Day (#125): Open Interpreter — Open-Source AI Coding Agent, Rewritten in Rust, Supporting Kimi, Qwen, and DeepSeek

#opensource #agents #rust #claude

Introduction

"A coding agent for open models — focused on getting the best performance out of low-cost models."

This is article #125 in the Open Source Project of the Day series. Today's project is Open Interpreter — the 66k-Star open-source AI coding agent, now rewritten in Rust, and one of the most important local agent platforms in the open-model era.

Open Interpreter's history has an interesting inflection point. It originally (2023) lit up GitHub as a Python project — one-line description: "run ChatGPT Code Interpreter on your local machine." The Python community version has since been handed off to a community fork (endolith/open-interpreter). The official team rewrote the entire project in Rust, based on OpenAI's Codex codebase, with a sharper focus on a specific question: how do you get Kimi K3, Qwen, DeepSeek, and other low-cost open models to perform at near-top-tier levels in agent scenarios?

The answer is the Harness system: different models use different agent prompting strategies, letting each model work in the way it does best.

What You'll Learn

  • The Harness system design: why different models need different agent prompting strategies
  • What the Rust rewrite brought: architecture and performance changes
  • Computer Use capabilities: browser automation and native UI control
  • ACP protocol: what Agent Communication Protocol is
  • Codex SDK compatibility layer: one-line model substitution
  • Positioning differences vs. Claude Code

Prerequisites

  • Familiarity with AI coding agent concepts
  • Experience using local or low-cost LLMs is helpful
  • Understanding how Claude Code, Codex, and similar tools work helps contextualize the Harness concept

Project Background

From Python to Rust: A Significant Transformation

Open Interpreter's evolution:

2023: Python version launches
  ↓  50k+ Stars within a year
  ↓  Concept validated, but Python has performance and deployment limits

2024-2025: Rust rewrite begins
  ↓  Based on OpenAI Codex codebase
  ↓  Focus: best agent performance for low-cost open models

Late 2025 / 2026: Rust version takes lead
  ↓  Python community version handed to endolith/open-interpreter
  ↓  Official pushes Rust v0.0.26 (July 2026)
Enter fullscreen mode Exit fullscreen mode

This rewrite isn't just a technical upgrade — it's a product repositioning: from "run ChatGPT Code Interpreter locally" to "agent framework optimized for open-weight models."

Author / Team

  • Organization: openinterpreter
  • License: Apache-2.0
  • Stack: Rust 96.6% + Python 2.6% + TypeScript
  • Version: v0.0.26 (July 2026)

Project Stats

  • ⭐ GitHub Stars: 66,000+
  • 🍴 Forks: 5,700+
  • 📦 Releases: 57
  • 📄 License: Apache-2.0
  • 🦀 Language: Rust 96.6%

The Harness System: Core Innovation

Harness is the most critical design concept in Open Interpreter.

What Is a Harness?

Different AI models are trained differently, have different prompt preferences, and use different tool-calling formats. Applying the same agent prompting strategy to every model typically produces poor results with some of them — not because the model is weak, but because the "usage pattern is wrong."

A harness is "the optimal way to use a specific model as an agent": the system prompt format, tool definition style, context compression strategy, and error recovery logic — all tuned for that particular model.

Open Interpreter ships multiple harnesses:

Harness Target Models Notes
native Default General-purpose
claude-code Anthropic Claude Claude agent format
claude-code-bare Anthropic Claude Stripped Claude format
kimi-code Kimi/Moonshot Provider-recommended format, default for Kimi
qwen-code Alibaba Qwen Optimized for Qwen series
deepseek-tui DeepSeek DeepSeek model format
swe-agent General SWE-bench style, software engineering focus
minimal General Minimal token consumption
zcode — —

The Kimi K3 example: When you launch with --model kimi, Open Interpreter automatically uses the kimi-code harness — the Moonshot AI-recommended, field-validated agent prompting format for Kimi models, implemented natively in Rust. The result is substantially better performance from Kimi K3 on coding tasks compared to using a harness optimized for Claude.

Switching Harnesses

Type /harness kimi-code or /harness qwen-code directly in the TUI — no restart required.

Computer Use

This is the capability that distinguishes Open Interpreter from many coding agents: it doesn't just write code and run commands — it can directly operate graphical interfaces.

Browser Automation

Integrates agent-browser to drive a real browser:

User: "Find the OpenMontage repo on GitHub, extract the first three paragraphs of the README"
          ↓
Open Interpreter launches browser
          ↓
Navigates to github.com
          ↓
Searches and locates target repository
          ↓
Extracts and returns content
Enter fullscreen mode Exit fullscreen mode

Native UI Automation

Integrates trycua/cua for native application control:

  • macOS: controls UI elements via Accessibility API
  • Windows: uses Windows Automation interface
  • Screenshot, click, type — works on any desktop application

QA Skill: A built-in skill built on these two capabilities. The agent automatically tests Web app or desktop app UIs without writing test scripts.

ACP Protocol Support

ACP (Agent Communication Protocol) is an open standard enabling interoperability between different AI agent tools.

# Run as ACP agent
interpreter acp
Enter fullscreen mode Exit fullscreen mode

Once launched, Open Interpreter acts as a standard ACP agent endpoint, callable from ACP-compatible editors (VS Code, etc.) or other agent orchestration systems. You can use Open Interpreter as the backend agent directly from your IDE, without switching to a separate Open Interpreter interface.

Codex SDK Compatibility

If you've built something with OpenAI's Codex SDK, one line of configuration switches the underlying engine to Open Interpreter:

{
  "codexPathOverride": "interpreter"
}
Enter fullscreen mode Exit fullscreen mode

Existing Codex SDK projects can switch to using local or other open-source models without code changes.

Quick Start

Install:

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

# Windows
irm https://www.openinterpreter.com/install.ps1 | iex
Enter fullscreen mode Exit fullscreen mode

After installation, run i or interpreter to launch the TUI.

Configure models:

# Use Kimi K3 (automatically enables kimi-code harness)
interpreter --model kimi

# Use DeepSeek
interpreter --model deepseek

# Use Qwen
interpreter --model qwen

# Use Claude
interpreter --model claude-opus-4-6
Enter fullscreen mode Exit fullscreen mode

TUI commands:

/model     Switch model
/harness   Switch harness
/help      All commands
Enter fullscreen mode Exit fullscreen mode

Config file (~/.openinterpreter/config.toml):

[agent]
model = "kimi-k3"
harness = "kimi-code"

[permissions]
allow_file_writes = true
allow_network = true
Enter fullscreen mode Exit fullscreen mode

Positioning vs. Claude Code

This question is worth answering directly:

Dimension Open Interpreter Claude Code
Open source ✅ Apache-2.0 Client open source
Model support Multi-model (Kimi, Qwen, DeepSeek, Claude...) Claude only
Cost Depends on model; free/low-cost models available Anthropic API pricing
Deployment Local, data stays on-device Local CLI, model in cloud
Customization Replaceable harnesses, extensible components Extensions via CLAUDE.md etc.
Computer Use Built-in browser + native UI automation Limited bash tool execution

These aren't in competition — they're different choices. If you primarily use Claude and value a polished experience, Claude Code is the better fit. If you want low-cost models like Kimi K3, fully local operation, or GUI automation capabilities, Open Interpreter is the more appropriate choice.

Links and Resources

Conclusion

Open Interpreter has gone through a meaningful transformation: from "run ChatGPT Code Interpreter locally" to "Rust agent framework optimized for open-weight models."

The timing is right. In 2025-2026, Kimi K3, Qwen, DeepSeek, and similar low-cost open models have been rapidly expanding their capability ceiling, increasingly approaching closed top-tier models. But using Claude/GPT-optimized agent formats on these models often produces suboptimal results. The Harness system's value is precise here: each model gets the prompting strategy it does best with.

The Rust rewrite brings performance advantages. More importantly, it makes ACP protocol support and Codex SDK compatibility possible — transforming Open Interpreter from a standalone tool into infrastructure that integrates into a broader ecosystem.

66k Stars mostly accumulated in the Python era, but active Rust iteration (57 releases, latest v0.0.26) shows this project continues to be seriously developed.

Explore PrimeSkills — A marketplace for handpicked AI Agents and skills. Each is validated in real enterprise workflows, stripping away hype and keeping only what truly works.

Welcome to my Homepage for more useful insights and interesting products.

Top comments (0)