Open Interpreter vs Claude Code — the portability runs one way

Open Interpreter and Claude Code are both terminal coding agents, and the choice between them turns on one asymmetry rather than on feel: Open Interpreter documents three request formats and takes a custom provider whose model is just a string in a config file, while Claude Code accepts only Anthropic-shaped formats and Anthropic writes that it "doesn't support routing Claude Code to non-Claude models through any gateway". Licence, account requirement, cost path and migration effort all follow from that single difference, and it is the one thing configuration cannot undo.

Settle which Open Interpreter you mean first, because the name moved. Since the relaunch announced on July 13, 2026, Open Interpreter is a Rust terminal agent that its own README calls "a fork of OpenAI's Codex"; the post adds that it is "built on OpenAI's Codex CLI" and released under Apache 2.0. The Python tool that ran generated code in a chat loop is a different program, frozen on PyPI at 0.4.3 from October 26, 2024. Almost every comparison article written before 2026 describes that one.

The two programs, as they stand on September 21, 2026

Repository identity, licence, stars, push date and the release tag were read from the GitHub API on September 21, 2026; the npm figures from the registry the same day; install and account statements from each vendor's own documentation, Claude Code setup and the Open Interpreter install page. A sibling page here recorded rust-v0.0.44 on September 18 — both numbers are correct for their dates, and releases in this line ship several times a month.

Three things this page is not comparing

The search results for this query fold in three unrelated products, each with a price that will wreck a budget if you attach it to the wrong tool.

Both tool prices checked September 21, 2026.

Who should pick which

Where the two clients actually differ

One row deserves expanding, because it is Open Interpreter's clearest inheritance from Codex. Beside the sandbox, it documents a separate path-based permission profile system: default_permissions selects a built-in profile such as :read-only or :workspace, custom profiles under [permissions.<name>] grant read, write or deny on path globs like **/*.env and on domain patterns, and "deny wins over broader grants". Its sandbox page names Seatbelt profiles on macOS and "Bubblewrap, seccomp, and related kernel sandboxing where available" on Linux and WSL, and says that when a requested policy cannot be enforced the intent is to "fail closed rather than silently running unsandboxed". All read from the project's documentation on September 21, 2026 and not executed here.

The ceiling configuration cannot lift

Both clients take a third-party endpoint, and the two setups look similar until you read what each will accept on the other side. Open Interpreter uses a TOML provider block, and every worked custom-provider example on its providers page is on the chat wire with a /v1-suffixed base URL:

# Top-level keys come first; anything after a [table] header belongs to it.
model_provider = "kunavo"
model = "claude-sonnet-5"

[model_providers.kunavo]
name = "Kunavo"
base_url = "https://api.kunavo.com/v1"   # OpenAI-compatible: /v1 included
env_key = "KUNAVO_API_KEY"               # the NAME of the variable, not the key
wire_api = "chat"

Claude Code takes an origin and one credential variable, and the variable chooses the header — ANTHROPIC_AUTH_TOKEN goes in Authorization: Bearer, ANTHROPIC_API_KEY in x-api-key:

# ANTHROPIC_BASE_URL is an ORIGIN. Claude Code appends /v1/messages itself,
# so a value ending in /v1 produces requests to /v1/v1/messages.
export ANTHROPIC_BASE_URL=https://api.kunavo.com
export ANTHROPIC_AUTH_TOKEN=sk-your-key   # sent as Authorization: Bearer

claude   # /status shows the active provider and base URL

The difference is not the syntax. It is that the first block names the endpoint and the model as free-text fields, while the second must point at something that speaks Anthropic Messages and serves Claude — and Anthropic states the boundary itself: "Any gateway that exposes a supported API format works. Anthropic doesn't endorse, maintain, or audit third-party gateway products, and doesn't support routing Claude Code to non-Claude models through any gateway." Four consequences worth knowing before you commit, all from Anthropic's gateway compatibility guide and feature availability page, checked September 21, 2026:

• Prompt caching can break with no error. If a gateway reshapes cache_control or flattens block-form system content, the symptom is "No error: the conversation bills as uncached input on every turn, visible as high input_tokens with little or no cache activity in usage". That is a cost failure that looks like nothing.
• Named features switch off. Whenever the base URL points at a host other than api.anthropic.com, Claude Code turns off Remote Control and server-managed settings "whatever the gateway forwards", and fine-grained tool streaming is off by default on any custom base URL.
• A credential moves your billing. While a gateway credential or apiKeyHelper is active, "a developer's claude.ai subscription isn't used" and the traffic bills per token to whoever owns the credential. Setting the base URL alone does not do this.
• Unknown model ids get assumed capabilities. "Claude Code assumes 200K, or 1M when the ID carries [1m]" for a context window it does not recognise, and a stream that goes silent for 300 seconds on an ANTHROPIC_BASE_URL connection is aborted.

One caveat on the Open Interpreter side, stated plainly: its providers page documents wire_api = "messages" as the value to use "only for Anthropic Messages-compatible providers", but every worked custom-provider example there is on the chat wire. So the value is documented while the configuration is not demonstrated, and this guide did not try it. Start on the chat wire. Neither client has been runtime tested against Kunavo.

What each one costs

Open Interpreter's side is short: the client is Apache-2.0, openinterpreter.com/pricing returned HTTP 404 on September 21, 2026, and its own models page carries no price statements at all. There is no plan to compare — only tokens at whichever provider you configure. The same vendor also ships a separate desktop product at openinterpreter.com/desktop, which is not the terminal agent compared here, and its relaunch post offers enterprises to "match or beat the cost offered by the labs while providing the same features" — a sales offer attached to no published rate.

All read from claude.com/pricing on September 21, 2026. Note what is not there: Anthropic's own FAQ says activity across web, desktop, mobile and Claude Code "all draws from the same pool" and that there is "no fixed message count", with 5-hour sessions and weekly limits on top. So no plan on this table comes with a publishable Claude Code quota, and any specific figure you see quoted for one is someone's guess.

A worked estimate on one assumed session

This is illustrative token arithmetic, not a measured task cost and not a bill ceiling. Assume one agent session that sends 300,000 uncached input tokens and receives 20,000 output tokens — a shape chosen because a Codex-style harness re-sends accumulated context every turn. Your repository and turn count will differ. Rates are live Kunavo catalog prices per million tokens.

Read the table as two blocks rather than one ranking. The first three rows are the apples-to-apples comparison: Open Interpreter's models page lists Anthropic ids and Claude Code requires them, so those are the rows where both clients can run the same work and the client choice is about workflow, not rate. The last two rows are the part Claude Code cannot reach at all — under these assumptions GPT-5.6 Luna models the same session at $0.029 against $0.800 for Claude Opus 5. That gap is the money value of the portability, and it is not a recommendation: cheapest listed price and lowest cost to finish the task are different claims, and a model that needs three attempts can cost more than one that needs a single pass.

Kunavo's catalog amount is a billing floor rather than a cap: when the upstream reports its charge, the bill is the greater of catalog cost and upstream cost times the applicable markup. Cache charges and external tools sit outside this example. The minimum top-up is $10 in prepaid credit, which is a funding minimum rather than a task fee or a subscription — see billing details.

Migration cost, in both directions

Moving from Claude Code to Open Interpreter is mostly cheap, because Open Interpreter reuses shared standards deliberately. Its README states the goal: "Today that includes repository AGENTS.md, shared .agents/skills directories, MCP, ACP, and the Codex exec protocol." So instructions and skills usually move as files rather than as rewrites, MCP servers are re-declared, and the new work is the provider block plus learning the harness and sandbox settings. That is a vendor design statement, not a migration this page tested.

Moving from Open Interpreter to Claude Code costs more than configuration, because it is a model decision as well as a client decision. If you were running an open-weight model, there is no supported route to keep it. If you were running Claude through a third-party endpoint, Claude Code can point at it — and you give up the subscription-only feature list, Remote Control, server-managed settings and the default-on tool-streaming behaviour described above. Budget the audit of what your team actually uses before the switch, not after.

Setting either one up

Kunavo publishes configuration references for both clients — Open Interpreter and Claude Code — and a published setup guide is a configuration reference, not a compatibility test. Neither has been runtime tested here against Kunavo's endpoint. Keep a working route available, run one bounded task on each, then read the charge your account actually recorded for it. Create a Kunavo account when you are ready to fund a key, and see ANTHROPIC_BASE_URL for the origin-versus-/v1 trap that catches most first attempts on the Claude Code side.

Comparing more broadly? Claude Code alternatives covers the wider field, and OpenAI-compatible API covers what the chat wire does and does not guarantee.

FAQ

Checked September 21, 2026 and cited inline: the Open Interpreter repository, licence and rust-v0.0.45 release via the GitHub API; the @anthropic-ai/claude-code npm registry entry; Open Interpreter's harness documentation; Anthropic's LLM gateway, gateway compatibility and pricing pages. Install paths, sandbox and permission settings, the providers and models pages, the PyPI package state and the feature-availability list were read the same day. Nothing on this page was runtime tested against any endpoint, no benchmark is quoted because no independent one was found, and every dollar example is illustrative token arithmetic rather than a measured task cost.