OpenHands Local Software Agent: Hardware Requirements by Model Size

By LLM Hardware team · Methodology ·

Key facts

Current UI
Agent Canvas, SDK, CLI. Legacy Local GUI deprecated.
7B
6.2 GB. Light issues only. Not a frontier coder.
27–32B Q4
18.2–21.2 GB
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: OpenHands is an open software-agent project: Agent Canvas, a Python SDK, a CLI, and a commercial Cloud. The legacy Docker Local GUI is deprecated.

How we got it: docs.openhands.dev and github.com/OpenHands/OpenHands, read 2 October 2026.

Checked:

Key fact: Local 7B is not a stand-in for a frontier coding model. A 7B Q4 is about 6.2 GB and is only for light issues.

How we got it: 7 × 0.5 × 1.2 + 2 = 6.2. Quality judgment, not a benchmark.

Checked:

Key fact: A 27–32B Q4 loop, the tier that can attempt SWE-style edits, needs about 18–21 GB.

How we got it: 27 × 0.6 + 2 = 18.2. 32 × 0.6 + 2 = 21.2. Muse Glimmer Q4 formula is 20 GB.

Checked:

Key fact: At the 22,000-token minimum in the OpenHands local-LLM docs, Qwen3-30B-A3B at Q4 needs about 22.5 GB and Qwen3-32B at Q4 about 27.0 GB.

How we got it: Formula result + 22,000 x 98,304 or 262,144 bytes of f16 KV cache (site KV cache guide). Docker sandbox memory is extra (site agent-workload guide pads 2 to 4 GB).

Checked:

Key fact: Qwen3.6-35B-A3B needs 20,480 bytes of f16 KV cache per token, so OpenHands' 22,000-token floor adds 0.45 GB to 23.0 GB of Q4 weights.

How we got it: config.json: 10 full-attention layers, 2 KV heads, head_dim 256 (the other 30 layers are linear attention). 2 x 10 x 2 x 256 x 2 bytes. Weights: 35B total (model card) x 0.5 x 1.2 + 2. Read 2026-10-30.

Checked:

Key fact: OpenHands' local setup page recommends at least 4GB of RAM, and its enterprise sizing guide budgets 4 GiB of memory per sandbox.

How we got it: docs.openhands.dev/openhands/usage/run-openhands/local-setup and docs.openhands.dev/enterprise/sizing-guide, read 2026-10-30.

Checked:

Key fact: Agent Canvas installs with npm install -g @openhands/agent-canvas and reaches a local Ollama as model openai/qwen3.6:35b-a3b at base URL http://host.docker.internal:11434/v1.

How we got it: docs.openhands.dev Agent Canvas setup and local LLMs pages, read 2026-10-30. host.docker.internal applies when the backend runs in Docker.

Checked:

Methodology explains the VRAM formula, the bytes per weight at each quantization, and the full source list.

OpenHands (the project that used to be called OpenDevin, under the All Hands banner) is a software agent: it edits code, runs commands, and can browse. Docs are at docs.openhands.dev. There is also OpenHands Cloud, which is their hosted sandbox. This page is the local install. Cloud needs no VRAM. Local needs a model that fits, and the docs are honest that a strong model is what makes the agent good. A 7B on a laptop is a demo.

Which binary you should actually run

The documentation index splits the project. Agent Canvas is the browser client. The Software Agent SDK and Agent Server are the library and the API. The CLI is described as feature-complete and kept stable. The old Local GUI, the Docker app from the former monorepo, is marked deprecated, with a pointer to Agent Canvas. Sandbox Server is a separate community control plane for creating those sandboxes. If a tutorial still starts with the legacy GUI image, it is a historical doc.

The model is not included. You point the agent at Ollama, vLLM, or another OpenAI-compatible endpoint. LM Studio’s local server works as that endpoint when you want a desktop UI for picking the GGUF. Browser tasks can use browser-use; the old OpenHands SDK deep link was not re-confirmed after the docs split, so start from the docs index.

Start OpenHands and point it at Ollama

Commands from OpenHands' Agent Canvas setup page and its local-LLM page, read on 30 October 2026. Agent Canvas needs Node.js 24 or later, uv, and Docker with the daemon running; on macOS and Windows, open Docker Desktop first.

First, start Ollama with the settings OpenHands asks for and pull its recommended model. If the Ollama desktop app is running, quit it before you run ollama serve.

OLLAMA_CONTEXT_LENGTH=32768 OLLAMA_HOST=0.0.0.0:11434 OLLAMA_KEEP_ALIVE=-1 nohup ollama serve &
ollama pull qwen3.6:35b-a3b

OLLAMA_HOST=0.0.0.0 makes Ollama listen on every network interface so the agent's containers can reach it. The Ollama FAQ describes the bind address but no login for the API, so keep this machine on a network you trust. Then install and start Agent Canvas:

npm install -g @openhands/agent-canvas
agent-canvas

Or run it once without installing, with npx @openhands/agent-canvas. The setup page opens the browser client on port 8000 of the same machine; agent-canvas --port 3000 moves it if 8000 is busy. In Agent Canvas, open Settings, LLM, the Advanced tab, and enter:

Field Value
Model openai/qwen3.6:35b-a3b: the openai/ prefix, then the ID your server lists at /v1/models
Base URL http://host.docker.internal:11434/v1 when the OpenHands backend runs in Docker and Ollama on the host; otherwise any address the backend can reach, ending in /v1
API key Any placeholder, such as local-llm; Ollama ignores it

Save, start a new conversation and send a short message to check the connection. If the agent cannot finish tasks, OpenHands' troubleshooting table points first at context length and tool-use support. The 32768 in the Ollama line is above the 22,000-token floor in its local-LLM docs.

Requirements by what you expect it to finish

This table sorts by task, not by a leaderboard, using our VRAM formula. Context for a repo is why the “fits” column is harsher than a chatbot table. Use the VRAM calculator with the slider off the 4K default.

Tier Model Good tasks for it
12 GB 7B Q4 (6.2 GB) or a tight 14B (10.4 GB) Light issues, a single-file edit. Not a multi-file SWE loop.
24 GB Qwen3.8-27B (18.2 GB), K2-32B (21.2 GB), Muse Glimmer (~20 GB formula, ~17 GB Meta K-quant) The first tier where a coding loop is worth the setup time.
64–128 GB Long context on that 32B, or a large MoE whose total weights fit Repo-wide context plus a browser. Still not “Claude quality” by magic of RAM.

OpenHands Cloud exists because local small models disappoint people. Use Cloud, or Cursor, or Devin, when the outcome matters more than the location of the weights. Use this page when the location is the requirement.

Worked example: the 22,000-token minimum on real machines

OpenHands' local-LLM docs set a floor that changes the hardware answer. With Ollama, set OLLAMA_CONTEXT_LENGTH to at least 22000, because the default of 4096 is too small. With LM Studio, set the context length to at least 22000 on lower-VRAM systems, and 32768 is recommended. At those lengths the KV cache is no longer a rounding error, and the agent's sandbox needs memory too.

Model plus f16 cache (formula result + cache, layer counts from our KV cache guide)

Model at Q4 At 22,000 tokens At 32,768 tokens
Qwen3-30B-A3B (20.3 GB) 22.5 GB 23.5 GB
Qwen3-32B (21.2 GB) 27.0 GB 29.8 GB

On a Mac, add the 2 to 4 GB our agent-workload guide pads for a running Docker sandbox, because it comes out of the same unified memory. On a PC with a discrete GPU, the sandbox mostly uses system RAM, not VRAM. OpenHands' local setup page recommends a modern processor and at least 4GB of RAM to run OpenHands, and its enterprise sizing guide budgets 4 GiB of memory, about 4.3 GB, for each sandbox. Plan system RAM as your operating system and Docker plus 4 GiB for each sandbox running at once; a bigger GPU does not change that figure.

Machine Qwen3-30B-A3B Qwen3-32B
24 GB GPU (RTX 3090, RTX 4090, RX 7900 XTX) 22,000 fits, 1.5 GB left. 32,768 at the edge, 0.5 GB left. Does not fit at 22,000.
RTX 5090 32 GB 32,768 fits, 8.5 GB left. 22,000 fits, 5.0 GB left. 32,768 fits, 2.2 GB left.
Mac mini M5 Pro 24 GB (about 20 GB usable) Does not fit; the weights alone are 20.3 GB. Does not fit.
Mac Studio M5 Max 36 GB (about 32 GB usable), with a 4 GB sandbox pad 32,768 fits, 4.5 GB left. 22,000 fits, 1.0 GB left. 32,768 does not fit.
Mac Studio M5 Max 64 GB (about 60 GB usable; Apple configure, no Amazon listing) Fits with room. Fits with room.

At OpenHands' minimum, the dense 32B no longer fits a 24 GB card and the 30B-A3B mixture-of-experts model does, because its cache per token is under 40 percent of the 32B's.

OpenHands' own pick is Qwen3.6-35B-A3B. The docs say it needs at least 24GB of VRAM for quantized variants, or at least 64GB of unified memory on Apple Silicon. Its model card and config.json, read on 30 October 2026, give 35B total parameters with 3B active and 40 layers in a hybrid layout: 30 Gated DeltaNet linear-attention layers and 10 full-attention layers with 2 KV heads of dimension 256. Only the 10 full-attention layers keep a per-token cache: 2 × 10 × 2 × 256 × 2 bytes = 20,480 bytes per token at f16, under a tenth of Qwen3-32B's 262,144. The linear-attention layers keep a fixed-size state that does not grow with context.

Context f16 cache Total with 23.0 GB of Q4 weights RTX 3090 24 GB RTX 5090 32 GB Mac Studio M5 Max 64 GB (60 GB usable, 4 GB sandbox pad)
22,000 tokens, OpenHands' floor 0.45 GB 23.5 GB Fits, 0.5 GB left Fits, 8.5 GB left Fits, 32.5 GB left
32,768 tokens 0.67 GB 23.7 GB Fits, 0.3 GB left Fits, 8.3 GB left Fits, 32.3 GB left
131,072 tokens 2.68 GB 25.7 GB Does not fit Fits, 6.3 GB left Fits, 30.3 GB left
262,144 tokens, the native window 5.37 GB 28.4 GB Does not fit Fits, 3.6 GB left Fits, 27.6 GB left

Weights are 35 × 0.5 × 1.2 + 2 = 23.0 GB by the site formula, counting every expert because all of them are loaded; Ollama lists the qwen3.6:35b-a3b tag at 23GB. On that count a 24 GB card holds about 48,800 tokens of cache, enough for OpenHands' 22,000 floor and its 32,768 recommendation with under 1 GB to spare. Hugging Face counts 36B parameters; on that count the weights are 23.6 GB and a 24 GB card no longer holds the 22,000-token floor, so treat 24 GB as the edge for this model, as OpenHands' own "at least 24GB" does. On a Mac, OpenHands asks for 64 GB. By the formula a 36 GB Mac Studio holds the weights, a 32,768-token cache and a 4 GB sandbox pad with 4.3 GB left, which is below OpenHands' figure, so follow theirs.

Machines from the catalog

For the 24 GB tier on Apple Silicon, the Studio M5 Max 36 GB (B0HGKSQMX6) leaves a little room past a 32B Q4 for the sandbox. For long context or a large MoE beside the agent, the EVO-X2 128 GB (B0F53MLYQ6) is the memory buy, with the usual Strix Halo bandwidth limit. A discrete 24 GB card remains the CUDA option: the RTX 3090 holds Qwen3.6-35B-A3B at OpenHands' 22,000-token floor with 0.5 GB to spare, on the card's 35B count. This listing is the Founders Edition of an Ampere-generation card, so check the seller and condition on the listing. The RTX 5090 32 GB holds the model's full 262,144-token window, but it was listed as unavailable at our last catalog check, so it has no link here. The Mac Studio M5 Max 64 GB, the Apple size OpenHands names for this model, is configured at Apple and has no Amazon listing in our catalog.

Mac Studio M5 Max 36 GB on Amazon

ASIN B0HGKSQMX6. Amazon Associates link. The live price is on that page, not locked in here.

GMKtec EVO-X2 128 GB on Amazon

ASIN B0F53MLYQ6. Amazon Associates link. The live price is on that page, not locked in here.

RTX 3090 Founders Edition 24 GB on Amazon

ASIN B08HR6ZBYJ. Amazon Associates link. The live price is on that page, not locked in here.

Sources

Questions

What command starts OpenHands locally?

OpenHands' Agent Canvas setup page gives npm install -g @openhands/agent-canvas and then agent-canvas, or npx @openhands/agent-canvas to run it without installing. It needs Node.js 24 or later, uv, and a running Docker daemon.

How do I connect OpenHands to Ollama?

In Settings, LLM, Advanced, set the model to openai/ followed by the Ollama tag, such as openai/qwen3.6:35b-a3b, the base URL to http://host.docker.internal:11434/v1 when the backend runs in Docker, and any placeholder API key. Start Ollama with OLLAMA_CONTEXT_LENGTH of at least 22000, as OpenHands' local-LLM page asks.

How much memory does Qwen3.6-35B-A3B's context take?

20,480 bytes per token at f16, because only 10 of its 40 layers keep a per-token cache. 32,768 tokens add 0.67 GB to 23.0 GB of Q4 weights, and the full 262,144-token window adds 5.37 GB.

How much system RAM does the sandbox need on a PC?

OpenHands recommends at least 4GB of RAM to run OpenHands, and its enterprise sizing guide budgets 4 GiB per sandbox. Count 4 GiB for each sandbox running at once, on top of your operating system and Docker.

A correction or a hardware question goes to the contact page.