Terminal agent, sandbox, approval mode, local model via /model.
Do not
Unattended root. Leave approval on.
Multi-step Q4
27B is 18.2 GB. 7B is only for a diff you will read.
Checked
2026-10-13
Checked 2026-10-13. Author: LLM Hardware team. Amazon prices are not stored or shown on this site.
Citeable facts
Key fact: Open Interpreter’s current docs describe a terminal coding agent with a sandbox and an approval mode. It is provider-agnostic, including a local model.
How we got it: openinterpreter.com/docs/terminal and the GitHub README, read 2 November 2026. The README says it is a fork of OpenAI Codex; local models use --oss with --local-provider ollama or lmstudio, and /model switches models.
Checked:
Key fact: Do not run it unattended as root. Approval mode is the safety control the docs describe.
How we got it: Same docs: a sandbox decides what is possible, and an approval mode decides when to ask. This guide recommends leaving the ask in place.
Checked:
Key fact: Simple scripted edits can use a 7B Q4 (about 6.2 GB). Multi-step tasks should be planned on a 27–30B Q4 (about 18–20 GB).
How we got it: VRAM formula. Not a measured success rate for computer-use tasks.
Checked:
Key fact: Open Interpreter runs on a local model with interpreter --oss --local-provider ollama (or lmstudio) and -m for the model; the docs suggest workspace-write with on-request approval if you are unsure.
How we got it: openinterpreter.com/docs/terminal CLI reference, providers and sandbox pages, read 2 November 2026.
Checked:
Key fact: For multi-step work with Qwen3.8-27B at Q4 (18.2 GB), a 24 GB GPU leaves 5.8 GB and a 32 GB machine leaves 13.8 GB; a 16 GB card does not hold it.
How we got it: 27 x 0.5 x 1.2 + 2 = 18.2 GB (site formula). Mac usable memory subtracts the 4 GB macOS reserve in data/hardware.json.
Checked:
Methodology
explains the VRAM formula, the bytes per weight at each quantization, and the full source list.
Open Interpreter’s documentation, read 2 November 2026, describes a coding agent in the terminal. You change into a project, run interpreter, and it reads files, edits them, and runs commands. The project README says it is a fork of OpenAI's Codex, written in Rust under the Apache-2.0 license, and the docs say it stays provider-agnostic: OpenAI, Anthropic, or a local model, switched with /model. A sandbox limits what can run. An approval mode decides when it must ask. That is the product this guide describes. Older writeups that frame it as an unattended desktop puppet are not what these docs say, and this guide does not revive that framing.
Local model, same brakes
The docs say you bring your own model. Ollama or LM Studio is how that stays on the machine. Open WebUI can be the chat door if you do not want to live in the terminal, but the approval story has to remain somewhere you will actually look. A local model does not make a destructive command safer. It only changes where the weights sat when the command was proposed.
A 7B will write a small script and then do something foolish on the third step. It suits “add a health endpoint” style edits inside a repo, with git so you can revert. For a task that chains several commands, use a 27B or Muse Glimmer, and keep the prompt that asks before it escalates. OpenHands is the alternative when you want a project sandbox rather than your real shell. Prefer that when the downside is high.
AI and automation help produce this content; every figure is checked against the cited sources and the site formula before publishing.
Run it on a local model: the documented commands
These commands are from the Open Interpreter docs and repo, read on 2 November 2026. The README calls this build "the new Rust version of Open Interpreter, based on Codex." Older guides that use pip and a Python package describe the original project, which the README says now lives on as a community-maintained fork (endolith/open-interpreter). Those instructions do not cover this build.
Install on macOS or Linux with curl -fsSL https://www.openinterpreter.com/install | sh, or on Windows PowerShell with irm https://www.openinterpreter.com/install.ps1 | iex. Restart the shell and check the binary with interpreter --version. The docs recommend Git for diffs and reviews, and git is also how you undo an edit.
The CLI reference lists two flags for a local model: --oss uses the configured local open source provider, and --local-provider picks ollama or lmstudio. The providers page lists both as built-in providers that need no key. -m sets the model. With Ollama running and the Qwen3.8-27B Q4 tag pulled (qwen3.8:27b, an 18GB download in the Ollama library):
Start it with interpreter --profile local. In the session, /status shows the model, provider, sandbox and approval setting, and /debug-config prints where each setting came from. Check both before the first task. The docs publish no table of defaults, so do not assume one.
What the sandbox and approval settings do
The docs split safety into two settings. The sandbox decides what a command can touch. The approval policy decides when Open Interpreter asks you first. A local model changes neither.
Sandbox mode (--sandbox)
What the docs say
read-only
"Commands can inspect allowed files but cannot write."
workspace-write
"Commands can write inside the active workspace roots. Network is off unless enabled."
danger-full-access
"No local sandbox boundary. Use only in an environment you intentionally trust."
The approval policy (--ask-for-approval, or approval_policy in the config) takes untrusted, on-request or never. The sandbox page's advice for anyone unsure is workspace-write with on-request, the pair in the profile above. This guide's rule stands on top of that: never set never on a machine that holds your mail or keys.
--yolo bypasses both approvals and the sandbox. The CLI reference calls it dangerous, and the sandbox page says to use it only inside an external sandbox such as a throwaway VM or isolated container.
Enforcement is per OS: Seatbelt profiles on macOS, Bubblewrap and seccomp on Linux and WSL, native sandboxing on Windows where configured. If a policy cannot be enforced, the docs say Open Interpreter should fail closed, not run unsandboxed.
Permission profiles are the newer, finer-grained form (:read-only, :workspace, :danger-full-access, or your own). The docs say to use one system at a time. A custom profile can deny paths, as in the docs' "**/*.env" = "deny" example, and deny wins over broader grants.
Scope: the permissions page says profiles govern only local sandboxed command execution. App connectors, MCP servers and browser or computer-use surfaces have their own controls. The command sandbox does not cover a desktop or browser tool you add.
Hardware by how much you are willing to let it attempt
Attempt
Model at Q4
Memory
One file, you read the diff
K2-Horizon-7B, 7.4 GB (Hub's 9B count)
8–12 GB. Approval stays on.
Several steps, still in a repo
Qwen3.8-27B, 18.2 GB, or K2-32B, 21.2 GB
24 GB minimum. 36 GB if the session is long.
Screenshots of the desktop
Muse Glimmer, formula 20 GB, Meta K-quant ~17 GB plus vision
24–32 GB envelope from Meta’s post. Not a reason to disable approval. Calculator.
This guide does not recommend a model tier for “control the whole computer while you are away.” That setup does not get a hardware recommendation. If the docs add a fully unattended mode later, this paragraph still stands until a human reviews the command policy.
Which catalog machines hold which model size
Figures use the site formula, parameters x bytes per parameter x 1.2 + 2 GB, at Q4 (0.5 bytes) or Q8 (1.0 bytes), for a short 4K to 8K context. GPUs count their full memory. Macs lose about 4 GB to macOS, as in our hardware catalog. See the methodology.
7B at Q4: 7 x 0.5 x 1.2 + 2 = 6.2 GB. K2-Horizon-7B on the Hub's 9B count: 9 x 0.5 x 1.2 + 2 = 7.4 GB.
14B at Q4: 14 x 0.5 x 1.2 + 2 = 10.4 GB.
Qwen3.8-27B at Q4: 27 x 0.5 x 1.2 + 2 = 18.2 GB. At Q8: 27 x 1.0 x 1.2 + 2 = 34.4 GB.
Usable memory
Catalog machines
What fits for this tool
8 GB
RTX 4060 (8GB)
A 7B or 9B at Q4 for single-file edits. K2-Horizon-7B leaves 0.6 GB for context.
12 GB
RTX 4070, RTX 5070, Arc B580 (12GB); Mac mini M6 16GB (about 12 GB after macOS)
A 14B at Q4 (10.4 GB). On the 16GB Mac mini that leaves about 1.6 GB, which is tight. No 27B.
A 14B at Q4 with 5.6 GB left for context. Qwen3.8-27B at Q4 (18.2 GB) does not fit.
20 GB
Mac mini M5 Pro 24GB, Mac mini M6 24GB (about 20 GB after macOS)
Qwen3.8-27B at Q4 with 1.8 GB left. Tight for a session that reads many files.
24 GB
RTX 3090, RTX 4090, RX 7900 XTX (24GB)
Qwen3.8-27B at Q4 with 5.8 GB left. The multi-step tier in the table above.
32 GB
RTX 5090 (32GB); Mac Studio M5 Max 36GB (about 32 GB after macOS)
Qwen3.8-27B at Q4 with 13.8 GB left for a long session. Q8 (34.4 GB) does not fit.
44 GB
Mac Studio M5 Max 48GB (Apple configure, no Amazon listing)
Qwen3.8-27B at Q8 (34.4 GB) with 9.6 GB left.
A bigger machine does not make a command safer. It lets the larger model plan longer chains, so keep approval on at the 24 GB and 32 GB tiers. For other models and context lengths, use the VRAM calculator.
Failure modes to expect
Context runs out first. Ollama's FAQ gives a default context of 4,096 tokens, raised with the OLLAMA_CONTEXT_LENGTH environment variable. An agent that reads files and command output fills that fast. Each step up adds key-value cache on top of the formula figures above; the KV cache guide sizes it.
The model spills out of GPU memory. Run ollama ps: the FAQ says "100% GPU" means the model is entirely in GPU memory, and a CPU/GPU split means part of it sits in system memory. On the 20 GB Mac and 24 GB GPU rows, a raised context can be enough to cause that.
No network inside the sandbox. In workspace-write, the docs say network is off unless enabled, so a step that needs to download packages has no network. The docs' setting is network_access = true under [sandbox_workspace_write], or network enabled in a permission profile. Turn it on per project, not globally.
Wrong wire API. The docs list Ollama and LM Studio on the Responses wire API. For a local server that only speaks Chat Completions, the docs give the --chat-completions flag, which does not change the base URL, credentials or model.
A command refuses to run. If the sandbox cannot be enforced on the system, the docs say Open Interpreter should fail closed. The fix is a supported sandbox setup, not --yolo on your daily machine.
Commands from old guides. Python-era instructions belong to the community fork, not this build. Check flags against interpreter --help and the CLI reference.
Ollama binds to 127.0.0.1 on port 11434 by default, per its FAQ, so the model server stays on this machine unless you change OLLAMA_HOST.
A normal user machine
Run it as your user, on a machine you can reinstall. The Mac mini M5 Pro 24 GB (B0HGGHNQY6) is enough for the 7B and tight for the 27B. The Studio 36 GB (B0HGKSQMX6) is the multi-step tier. Neither listing is a license to disable prompts. A 24 GB GPU is the same fit on Windows, with the same rule.
This site uses cookies and shows personalised ads via Google AdSense. We and our partners store and access information on your device to serve relevant ads and improve your experience.
You can accept all cookies, decline (non-personalised ads only), or
manage preferences.
See our Privacy Policy.
We use Google Analytics
This site would like to use Google Analytics to understand how visitors use the site. If you accept, Google Analytics will load. If you decline, or if you make no choice, Google Analytics will not load. No ads are shown on this visit.
See our Privacy Policy and Cookie Policy.
Cookie preferences
Choose which cookies you allow. Strictly necessary cookies are always active.
Strictly necessary
Session state, security, and performance. Cannot be disabled.