Self-host Open Interpreter on a Cube

Open Interpreter is an open-source agent that runs code on your machine — shell commands, file edits, browser automation — from a single prompt. It is MIT-licensed with about 68,000 stars on GitHub (verified 2026-09-13). A Cube is a good place to run it: you get a long-lived server-resident agent with no per-seat pricing and no sandboxed container escape risk.

The install is one command. The part worth reading carefully is Step 4 — Open Interpreter runs in a terminal TUI by default. If you want it reachable from a chat app, you need to put a thin wrapper around it; the easiest path is to run it as a long-livedinterpreter process and ssh in to drive it.

Before you start

Open Interpreter ships a single-binary installer for macOS, Linux and Windows, plus an npm path. On a Cube running Ubuntu 24.04, the binary installer is the shortest path. Open Interpreter itself is small; the heavy resource is the LLM it drives.

• A Cube of 2 vCPU, 4 GB RAM, 40 GB disk — about $0.0140/hour, roughly $0.34/day or $10/month if left running. Comfortable for the agent plus a small local model.
• If you want to run a capable local model (around 7B parameters), plan on 8 GB RAM and 8 GB of disk for the model weights alone, in addition to the agent. The Cube size for that is 4 vCPU, 16 GB RAM, 100 GB disk.
• An SSH key pair, as with any Cube.
• An API key from an AI provider — or a local Ollama install if you would rather skip the paid API.

Step 1 — Create the Cube

Create a Cube with the Ubuntu 24.04 image. Open Interpreter runs on Linux; Ubuntu 24.04 is the image Krova validates against.

Size it at 2 vCPU / 4 GB / 40 GB if you are pointing Open Interpreter at a paid AI provider, or 4 vCPU / 16 GB / 100 GB if you want to run a local 7B model through Ollama on the same Cube.

Step 2 — Connect over SSH

ssh ubuntu@<cube-host> -p <port>

Step 3 — Run the installer

Open Interpreter publishes a single install script. Fetch it, look at it, then run it:

curl -fsSL https://www.openinterpreter.com/install -o oi-install.sh
less oi-install.sh
bash oi-install.sh

The installer provisions a Python runtime when needed, then drops an i (or interpreter) command on your PATH. Confirm:

interpreter --version

Step 4 — Pick the model backend

Open Interpreter accepts a model and provider either through environment variables or an interactive prompt on first launch. The two reasonable choices on a Cube are the same shape as the other self-host guides.

Paid API

Set OPENAI_API_KEY (or the equivalent for Anthropic, Groq, etc.) and launch with interpreter. The agent uses the provider's hosted models and bills on the provider side.

Local Ollama on the same Cube

For a no-per-message bill, install Ollama on the same Cube and point Open Interpreter at it:

curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.1:8b

Then set OPENAI_API_BASE=http://localhost:11434 and pick the llama3.1:8b model when launching. Everything from there is local.

Step 5 — Launch the agent

Open Interpreter runs in a terminal TUI by default. Launch it in a detached session so it survives your SSH window:

tmux new -s oi interpreter

From there, attach with tmux attach -t oi whenever you want to drive it. The agent executes shell commands, edits files, and runs browser automation through the same prompt — it is closer to a coding agent than a chat assistant, which is why there is no built-in chat-app bridge.

If you want Open Interpreter reachable from a chat app, you need to wrap it. The simplest path is a thin HTTP server that accepts a message, forwards it to the running interpreter process, and posts the result back. The community publishes several such wrappers; pick one, deploy it on a second Cube port, and map a domain to it the same way the Letta guide describes.

Step 6 — Leave it running

Open Interpreter is meant to live on the Cube and respond to your prompts whenever you SSH in. tmux is the simplest path. If you want it to survive a Cube reboot, wrap the launch in a systemd unit that starts tmux new -d -s oi interpreter on boot.

What it costs

The 2 vCPU / 4 GB / 40 GB Cube described here bills at about $0.0140/hour — roughly $0.34/day, or $10/month if left running. Usage is metered by the minute.

On top of that, either an AI provider bill (paid per message) or the local Ollama path. Ollama is free to run; the only cost is the larger Cube to fit the model weights in RAM. Open Interpreter is fully open-source with no paid tier — the upstream project is github.com/OpenInterpreter/open-interpreter.

If you power the Cube off, Open Interpreter stops responding until you power it back on and attach to the tmux session again. You are billed only for storage while it is stopped.

Cleaning up

Deleting the Cube removes Open Interpreter, any wrapper server, and local model weights along with the disk. The agent has no built-in persistence, so there is usually nothing to snapshot.

Next steps

• Self-host Letta on a Cube — the memory-first alternative if you want a chat-app bridge built in.
• Self-host OpenClaw on a Cube — the broader chat-app support alternative.
• Cubes — sizing, snapshots, and how billing works when a Cube is stopped.