Skip to main content
NexGPU

AI software-engineering agent framework

The OpenDevin you're looking for is called OpenHands now — and one 24GB card turns it into a private coding agent

The paper itself says "f.k.a. OpenDevin": the project was renamed OpenHands and the repos moved from All-Hands-AI to the OpenHands org. The framework barely touches your GPU — every gigabyte of VRAM goes to the model you self-host.

Sign up freeView pricing

Identity first. OpenDevin was the open-source software-engineering agent platform started in 2024 by Xingyao Wang and collaborators. It was renamed OpenHands, and the ICLR 2025 paper is titled "OpenHands: An Open Platform for AI Software Developers as Generalist Agents (f.k.a. OpenDevin)". So every "OpenDevin install guide" you find is really telling you to install OpenHands. The GitHub org changed from All-Hands-AI to OpenHands; the licence is still MIT.

What matters more is that the project has split into four repos and changed shape. The flagship `OpenHands/OpenHands` repo now hosts Agent Canvas — a self-hosted control center for coding agents, currently 1.15.0, launched via the npm package `@openhands/agent-canvas` or the image `ghcr.io/openhands/agent-canvas:1.15.0` on port 8000, requiring Node.js 22.12+ and uv. The engine that actually runs agents lives in `OpenHands/software-agent-sdk` (PyPI: `openhands-sdk`, `openhands-tools`, `openhands-agent-server`, all on 1.43.x), carrying a SWE-Bench score of 77.6. The other two repos are `typescript-client` and `automation` (schedules and webhooks). The docs now file "Local GUI", "CLI" and "V0 Reference" under Deprecated Projects, with the old V0 Runtime concept replaced by V1 Sandboxes — follow a 2024-era `openhands-ai` tutorial and you will fight it the whole way.

OpenHands itself is an orchestration layer: it manages conversations, tool calls, file edits, the terminal and the sandbox, and it runs on CPU. The VRAM bill belongs entirely to the model. On 2026/05/21 the docs updated their recommendation: for self-hosting, start with Qwen3.6-35B-A3B — a 35B-total MoE activating roughly 3B parameters per token (256 experts, 8 routed per token), Apache-2.0, 262144 native context, vision included. The official bar is "a recent GPU with at least 24GB of VRAM for quantized variants, or multiple GPUs for full precision and larger context windows". Which is exactly why renting beats buying: you pay only for the hours the agent is actually working.

01 —

The model OpenHands officially recommends: Qwen3.6-35B-A3B, tier by tier

These are the real file sizes published on HuggingFace, not estimates. KV cache is counted separately.

VersionParametersVRAMContextNotes
Qwen/Qwen3.6-35B-A3B (bf16 safetensors)35B total / ~3B active (A3B)66.96GiB of weights (71.9GB)262144 nativeOfficial full-precision weights. They fit on a single 80GB card but with almost no headroom — the official vLLM/SGLang examples use --tensor-parallel-size 2.
Qwen/Qwen3.6-35B-A3B-FP835B-A3B34.89GiB of weights262144 nativeThe official FP8 checkpoint, downloaded even more than bf16. Fits one 48GB card; on 80GB you can max out both context and concurrency.
unsloth Qwen3.6-35B-A3B-Q8_0 GGUF35B-A3B34.37GiB (UD-Q8_K_XL is 35.81GiB)Your choice; OpenHands wants 32768+The closest-to-full-precision tier on the llama.cpp / LM Studio / Ollama path — useful as a quality baseline to measure the cheaper quants against.
unsloth Qwen3.6-35B-A3B-UD-Q5_K_M GGUF35B-A3B24.64GiB128K is comfortable (~2.5GiB of KV)The sweet spot for a 32GB card. Enough left over to push context to 131072 without an OOM.
unsloth Qwen3.6-35B-A3B-UD-Q4_K_M GGUF35B-A3B20.61GiB (MXFP4_MOE variant: 20.22GiB)32768 recommendedThis is the tier the official "at least 24GB" line was drawn around. On a 24GB card it leaves roughly 2.5GiB — fine for 32K context, but don't run anything else alongside it.
unsloth Qwen3.6-35B-A3B-UD-IQ4_XS GGUF35B-A3B16.51GiB (UD-IQ3_S 12.74GiB / UD-Q2_K_XL 11.45GiB)32768 with room to spareThe tier that is genuinely comfortable on a 24GB card — room for the vision tower (mmproj-F16, 0.84GiB) and long context at the same time.

02 —

Pick a card by how you'll use it: real NexGPU rates

Qwen3.6-35B-A3B uses hybrid linear attention — only 10 of its 40 layers are full attention (full_attention_interval=4), with 2 KV heads at head_dim 256. That works out to roughly 20KiB of KV cache per token: about 0.6GiB at 32K context and only ~2.5GiB at 128K. On this model VRAM is almost entirely weights, so size your card against the checkpoint.

  • Prove it works: single-card GGUF Q4, confirm OpenHands actually calls tools

    RTX 4090 24GB$0.540/GPU-hr

    UD-IQ4_XS at 16.51GiB or UD-Q4_K_S at 19.46GiB leaves real KV headroom, holds 32K context steadily, and an afternoon of validation costs under two dollars.

  • Daily driver: Q5/Q6 quant with 131072 context so the agent can read a whole repo in one pass

    RTX 5090 32GB$0.723/GPU-hr

    UD-Q5_K_M at 24.64GiB plus ~2.5GiB of KV for 128K still leaves margin, and Blackwell handles FP4/FP8 natively so the MXFP4_MOE tier runs at full speed.

  • Shared team instance: official FP8 weights with vLLM concurrency, feeding Agent Canvas automations

    A100 PCIE 80GB$0.824/GPU-hr

    FP8 weights take 34.89GiB — under half the card — leaving 40GB+ for KV and batched requests, and it costs just $0.007 more than the 48GB A6000 at $0.817.

  • Full-precision baseline: bf16 with TP=2, matching the official example exactly

    RTX A6000 48GB × 2$0.817/GPU-hr (two cards: $1.634/hr)

    66.96GiB of weights split in half lands at ~34GiB per card, which is precisely what the official SGLang/vLLM --tensor-parallel-size 2 and --context-length 131072 examples assume.

03 —

Getting OpenHands running on NexGPU

Four steps: pull weights, start an OpenAI-compatible endpoint, start Agent Canvas, fill in the LLM settings. Less time than a coffee break.

  1. 01

    1. Spin up a vLLM instance and pull the official FP8 weights

    At console.nexgpu.net pick an A100 PCIE 80GB and choose the prebuilt vLLM image — there are 2,000+ images including PyTorch, vLLM and plain Ubuntu CLI, so you never touch a CUDA install. The 34.89GiB FP8 checkpoint lands on instance storage in minutes.

    huggingface-cli download Qwen/Qwen3.6-35B-A3B-FP8 --local-dir /workspace/qwen3.6-35b-a3b-fp8
  2. 02

    2. Start an OpenAI-compatible endpoint

    OpenHands speaks the OpenAI protocol, so vLLM, SGLang, Ollama and LM Studio all qualify. --enable-prefix-caching pays off enormously in agent workloads: the system prompt and tool definitions repeat on every turn, and cache hits cut time-to-first-token sharply. For more speed, Snowflake's ArcticInference with suffix speculative decoding reports up to 2x in some cases.

    vllm serve /workspace/qwen3.6-35b-a3b-fp8 --served-model-name Qwen3.6-35B-A3B --host 0.0.0.0 --port 8000 --api-key mykey --enable-prefix-caching
  3. 03

    3. Start Agent Canvas

    Mind the ports: the Agent Canvas image also listens on 8000 and will collide with vLLM, so map it to 8080. Point PROJECTS_PATH at the code you want the agent to edit — doing this on a rented instance is far safer than mounting docker.sock on your laptop, because a bad run just means destroying the instance.

    export PROJECTS_PATH=$HOME/projects && mkdir -p $PROJECTS_PATH $HOME/.openhands && docker run -it --rm -p 8080:8000 -v $HOME/.openhands:/home/openhands/.openhands -v $PROJECTS_PATH:/projects ghcr.io/openhands/agent-canvas:1.15.0
  4. 04

    4. Point the LLM settings at your own endpoint

    Open the UI, go to LLM settings, click "see advanced settings" and flip the Advanced toggle. Set Custom Model to openai/Qwen3.6-35B-A3B (the openai/ prefix is mandatory), Base URL to your endpoint, and API Key to the mykey you passed vLLM. Context must be at least 22000, ideally 32768 — this single setting is the most common failure in local OpenHands deployments. Prefer the SDK over the UI? Three pip packages and you're scripting.

    pip install openhands-sdk openhands-tools openhands-agent-server

What a self-hosted OpenHands costs an eight-person backend team per month

Scenario: Agent Canvas plus automations handling dependency upgrades and automated code review, 10 hours a day on weekdays, running official FP8 weights on an A100 PCIE 80GB. The arithmetic, in full: compute is 220 hours (10 hours × 22 working days) × $0.824 = $181.28; storage holds the 37.5GB FP8 checkpoint, a ~22GB Q4 GGUF fallback, plus Docker images and sandbox layers — call it 100GB, so 100 × $0.414 = $41.40 (note that compute billing stops when the instance stops, while storage keeps billing until it is destroyed); egress at 300GB × $0.0081 = $2.43. Total: about $225.11/month, which is under $29 per engineer. And before committing to any of that, you can spend $0.81 — RTX 4090 24GB at $0.540 × 1.5 hours — running UD-IQ4_XS to confirm the agent genuinely calls tools and edits files. Per-second metering, no minimum, no setup fee, no quota request: failed experiments cost almost nothing.

04 —

FAQ

Is OpenDevin still maintained? Why won't the GitHub repo load?

It is maintained — it just isn't called OpenDevin. The project was renamed OpenHands and the GitHub org moved from All-Hands-AI to OpenHands, which is why old links redirect or break. The ICLR 2025 paper preserves the "f.k.a. OpenDevin" note, and the licence is still MIT. Watch the structure though: `OpenHands/OpenHands` is now Agent Canvas (1.15.0), the agent engine moved to `OpenHands/software-agent-sdk`, and V0 Reference, Local GUI and CLI are all filed under Deprecated Projects. To walk the new architecture end to end in a clean environment, a NexGPU instance boots in seconds — no scrubbing old versions off your workstation.

How much VRAM does OpenHands (OpenDevin) itself need?

None. OpenHands is the orchestration layer — conversation state, tool calls, file edits, terminal, sandbox — and it runs on CPU with a few hundred MB of RAM. The VRAM bill belongs entirely to the model you self-host: for the recommended Qwen3.6-35B-A3B that's 20.61GiB at Q4, 34.89GiB at FP8, and 66.96GiB at bf16. So size your GPU against the model, not the framework. NexGPU rents everything from an RTX 3090 24GB at $0.193/GPU-hr up to an H200 141GB at $6.660/GPU-hr, billed per second — pick the tier your quant lands in.

Which model should I run locally with OpenHands, and is a 24GB card enough?

As of the 2026/05/21 docs update the official pick is Qwen3.6-35B-A3B: a 35B-total MoE with roughly 3B active parameters, Apache-2.0, 262144 native context. The stated requirement is "at least 24GB of VRAM for quantized variants". Concretely: UD-Q4_K_M is 20.61GiB, which leaves about 2.5GiB on a 24GB card — enough for 32K context and not much else. For breathing room use UD-IQ4_XS at 16.51GiB. NexGPU's RTX 4090 24GB is $0.540/GPU-hr; if you'd rather have the headroom up front, the RTX 5090 32GB is $0.723/GPU-hr.

Why does OpenHands act like a plain chatbot with my local model — no tool calls, no file edits?

Nine times out of ten the context window is too small. The OpenHands system prompt plus tool definitions is long, and Ollama's default 4096 can't hold it — the docs put it bluntly: "not even the system prompt will fit". Set OLLAMA_CONTEXT_LENGTH to 32768 (22000 is the floor), or in LM Studio raise Context Length above 22000 in the model load parameters and enable Flash Attention. The remaining cases are models that are simply weak at tool calling; the community reports qwen2.5-coder-14b-instruct as a workable fallback. Longer context means more VRAM, which is the most direct argument for renting a bigger card — on NexGPU, swapping cards and restarting takes minutes.

OpenHands in Docker can't reach LM Studio or Ollama on my host. What's wrong?

Two classic traps. First, LM Studio on Linux binds only to 127.0.0.1 by default, so no amount of --add-host host.docker.internal:host-gateway will reach it — enable "Serve on Local Network" in the server settings to switch the bind to 0.0.0.0. Second, the Base URL host is usually wrong: from inside the container use host.docker.internal, with port 1234 for LM Studio, 11434 for Ollama, and 8000 for vLLM or SGLang. One command settles it: docker exec -it openhands-app curl -s http://host.docker.internal:1234/v1/models — if the model list comes back, you're connected. Put the inference endpoint and the agent on the same NexGPU instance and this whole class of networking problem disappears.

OpenHands wants docker.sock mounted and full filesystem access for the agent. Is that safe?

The official README warns about it directly: without a sandbox the agent has full access to your filesystem. The right answer is to use the Agent Server sandbox (V1 Sandboxes, which can run in Docker or Kubernetes) and to not run any of it on your development laptop. Putting the whole stack on a dedicated rented instance is the cleanest isolation you can get: mount only the PROJECTS_PATH you're willing to let it rewrite, and if something goes wrong, destroy the instance and compute billing stops on the spot. NexGPU spans 51 countries and regions, 1,175 verified rentable nodes and 2,498 GPUs, with SSH, Jupyter, web terminal, REST API and CLI access, plus bilingual support over Telegram with no ticket queue.

More in AI agents and workflows

Every model guide

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.

Sign up freeTalk to sales

Sign up to browse live network pricing. No payment method required.