Categories Alternatives News Submit a Tool Advertise About

Is OpenHands Free? What It Really Costs to Run

The software is $0 and MIT-licensed, and self-hosting has no conversation limit. Your real cost is the model: roughly $5–15/month on budget API models for daily bug-fixing, $50–200+ on frontier models for hard multi-file work, or $0 in tokens with local models — plus the compute you run the sandbox on. The hosted tier is free too, but capped at 10 conversations per day.

MITSelf-hostedUnlimited conversationsBYO model
8.2 / 10
AICoding score
Visit Official Site ↗
Quick answer
$0 MIT software, self-hosted — no subscription, no seat fee
Unlimited Conversations when self-hosted — cloud free tier caps at 10/day
$5–15/mo Realistic token bill on budget models
Quote Enterprise self-hosted — price never published
Updated September 12, 2026 Based on research & community feedback
License MIT (open source)
Tool cost Free (self-hosted)
Core Autonomous agent loop (CodeAct)
Runtime Docker / K8s sandbox
Models Any tool-calling LLM
SWE-bench ~72% Verified
Interfaces SDK · CLI · GUI · API

Quick Verdict

8.2 / 10 — the most mature open-source autonomous coding agent in 2026: MIT licensed, model-agnostic, Docker-sandboxed, and free to self-host. The closest open-source answer to Devin.

OpenHands (formerly OpenDevin) completes whole tasks end to end — read the repo, write code, run tests in a sandbox, open a PR — while you bring any LLM. That removes the per-seat bill and the vendor lock-in, and moves the cost to tokens and infrastructure you control.

Use OpenHands if…

  • You want autonomous task completion without a per-seat subscription
  • You want the model to be a cost lever — frontier for hard tasks, cheap or local for routine ones
  • You need sandbox-isolated, auditable runs and code that never leaves your perimeter
  • You are automating a backlog or migrating a large codebase with agent fleets

Skip OpenHands if…

  • You want a managed product with first-party support and no infrastructure work
  • Your team will not run Docker or Kubernetes, and nobody wants to own upgrades
  • You need a predictable flat bill — token spend tracks how much you actually delegate

Core Features

Replaces a junior-dev loop

Autonomous end-to-end agent

Describe a task in natural language and OpenHands runs the whole loop: read the repo, write and edit code, run tests in a sandbox, browse the web, iterate, and open a pull request for human review. It completes the entire task — not just the next line. This is the "AI software engineer" model Devin popularized, delivered open source.

Bring your own model

Model-agnostic by design

Bring your own model: Anthropic Claude, OpenAI GPT, Google Gemini, or open-weight models (Llama, Qwen) via any OpenAI-compatible endpoint or litellm. Local models through Ollama keep code fully on-premises. The OpenHands Index benchmarks rank models on real SWE performance so you can tune the price/quality mix — Claude Opus for hard tasks, a cheaper model for routine steps.

Safe by default

Sandboxed execution by default

Every agent runs in an isolated Docker or Kubernetes container with its own filesystem, shell, browser and editor. It cannot reach your host machine or other projects, and fine-grained access controls decide what it may do. Sandboxing is the default, not an add-on — the core safety story for autonomous agents.

Every action logged

Event-sourced, auditable runs

Agent state is derived from an immutable log of typed events (Action → Execution → Observation) rather than a mutable variable. That means runs are replayable, branchable, and fully auditable — you can step back to any point and see exactly what the agent saw and did. Enterprise-grade traceability for regulated teams.

Scale to a fleet

Parallel agent orchestration ("fleet")

Spin up hundreds or thousands of agents simultaneously, each in its own container, to process an entire backlog in parallel — dependency bumps, CVE remediation, codebase migrations, and test-coverage expansion across many repos at once. This is what turns OpenHands from a productivity tool into an engineering force multiplier.

Pricing

Self-hosted (MIT)
$0
free forever

The whole platform — SDK, CLI, web GUI, REST API, agent loop, sandboxing, audit log — with no conversation limit and no gated features. Verified against the official pricing page, September 13, 2026.

  • MIT open source
  • Unlimited conversations
  • Docker / K8s sandbox
  • No seat or usage fee
Cloud Individual
$0
capped at 10 conversations/day

Hosted OpenHands for one user, with desktop and mobile access, API access and Jira/Slack integrations. Bring your own model keys, or use OpenHands-hosted models billed at cost with no markup.

  • 1 user
  • 10 conversations per day
  • BYOK or at-cost models
  • No credit system
Enterprise
Custom
quote only

SaaS or self-hosted in your own VPC with SAML/SSO, unlimited users, multi-user RBAC, unlimited concurrent conversations per user, Large Codebase SDK, centralised billing and priority support. No price is published.

  • Unlimited concurrency
  • SSO + RBAC
  • VPC self-hosting
  • Named customer engineer

* Verified against the official OpenHands pricing page on September 13, 2026. Note what is deliberately absent: there is no mid-tier team plan — you either self-host for free with unlimited conversations, stay inside the free cloud cap of 10 conversations a day, or move to a quoted Enterprise contract.

What OpenHands Really Costs

Tokens and compute — the bill a managed agent hides
Task / Plan Usage Typical cost What to watch
Self-hosted, own keys Docker on your own machine, any provider key $0 software + tokens The only configuration with unlimited conversations
Budget API models Daily bug-fixing and small features on DeepSeek / Gemini Flash ~$5–15/mo in tokens The realistic entry bill for regular use
Frontier models Hard multi-file refactors on Claude Opus / GPT-class $50–200+/mo in tokens Comparable work to a $500/mo managed agent
Local models (Ollama) Private or regulated code, on-prem GPU $0 in tokens You pay in hardware and slower runs instead
Cloud Individual Hosted agent, one user $0 up to 10 conversations/day The cap is the constraint, not the price
Cloud with OpenHands models Skip managing provider keys At cost, no markup Token-based — there is no credit system
Infrastructure you own K8s cluster, sandbox containers, agent fleets Your compute bill The line item managed agents hide inside their price
Enterprise self-hosted In-VPC deployment, SSO, unlimited concurrency Custom quote No published number anywhere

OpenHands itself adds no markup — the two real costs are model tokens and the compute you run the sandbox on. Figures verified September 13, 2026 against the official pricing page; monthly token ranges are community-reported experience, not vendor quotes.

OpenHands Deals & Ways to Pay Almost Nothing

Offers, free tiers & ways to pay less
Free Free open source — self-host on Docker Details →
Money-Saving Budget API models → ~$5-15/mo for daily use Details →

There are no coupon codes here — the money levers are self-hosting, model choice, and running local models when privacy matters.

vs The Field

OpenHands vs Devin

Open-source Devin alternative

Both run the same autonomous "agent completes the ticket" loop. OpenHands is MIT-licensed, model-agnostic and free to self-host; Devin is a managed commercial product on a per-seat subscription with vendor-locked infrastructure. OpenHands wins on cost and freedom (and you keep your own model + data); Devin wins on polished UX, managed reliability and first-party support. Pick OpenHands if you want Devin-like autonomy without the bill.

OpenHands for cost/freedom · Devin for managed UX

OpenHands vs Claude Code

Autonomous agent vs terminal CLI

Claude Code is a CLI coding agent locked to Anthropic models, run locally with a mature first-party UX. OpenHands is a web-UI autonomous agent that is model-agnostic and runs in a sandboxed container, built for unattended end-to-end completion (it opens the PR for you). Claude Code for interactive terminal pair-work; OpenHands for delegating whole issues to a self-hosted agent.

Claude Code for maturity · OpenHands for autonomy + freedom

OpenHands vs Cline

Whole-task agent vs in-editor pair

Cline is a VS Code sidebar agent that edits files with you watching and approving each step inside your editor. OpenHands is a full autonomous agent in a sandbox that completes entire tasks and opens PRs without supervision. Cline gives tighter editor control; OpenHands gives hands-off task completion. Many teams run Cline for daily edits and OpenHands for backlog automation.

OpenHands for autonomy · Cline for in-editor control

What It Is Worth Running It For

Autonomous bug fixing & issue triage

Assign a GitHub issue and the agent reproduces the bug, writes the fix, adds a regression test and opens a PR — often same-day. The strongest, most-proven OpenHands use case for support and maintenance backlogs.

Cost path:Free self-hosted + Claude

Escape Devin's price tag

Get Devin-like autonomous development without the per-seat subscription. Self-host OpenHands, bring your own model key, and pay only for LLM tokens — often a fraction of a managed agent's monthly cost.

Cost path:Free OSS + BYO key

Legacy & large-scale migration

Parallel agent fleets migrate codebases, modernize patterns, and apply dependency or framework upgrades systematically across whole repos — the agent understands old patterns and applies the new ones consistently.

Cost path:Fleet (K8s)

Enterprise self-hosted (data residency)

Deploy in your own VPC with RBAC and audit logging so source code never leaves your perimeter. Meets ITAR / HIPAA / finance constraints that cloud-only agents cannot.

Cost path:Enterprise K8s

Local & private models

Run with Ollama or on-prem GPUs to get near-SWE-bench results with zero data egress and $0 model cost. Ideal for proprietary or regulated codebases.

Cost path:Ollama / on-prem

The Free Path: What You Actually Have to Run

Self-hosting is the reason the software is free — this is the real work
01

Install the prerequisites

Node.js 22.12+ with npm/npx, Docker, and uv. Docker runs the sandboxed backend; uv backs the local agent-server runtime. The Docker-only path lets you skip Node entirely.

02

Launch the local stack

One command starts the full local stack — Canvas client, Agent Server, Automation Server and ingress — on http://localhost:8000. This is the free, unlimited-conversation path; nothing here talks to a vendor account.

03

Pick the cheapest model that works

In Settings > LLM Profiles add a provider key. This is your cost dial: a budget model for routine tasks, a frontier model only for hard problems, or Ollama for $0 tokens. Switching per conversation is the main lever on your monthly bill.

FAQ

Is OpenHands free?

Yes. OpenHands is MIT-licensed open source — the agent platform, SDK, CLI, web UI and REST API are free to self-host forever. You only pay for the LLM you connect (or $0 if you run local models via Ollama). There is no paid tier locking features behind a subscription; the project is backed by an $18.8M Series A but the software stays open.

Is OpenHands the same as OpenDevin?

Yes — OpenHands was previously called OpenDevin. It rebranded to OpenHands in 2024 but is the same project: the open-source autonomous AI software engineer. You will still see "OpenDevin" in older articles and the GitHub history, but both names refer to the same codebase (All-Hands-AI/OpenHands).

What is OpenHands used for?

OpenHands is an autonomous AI software engineer that completes entire engineering tasks end to end: it reads your codebase, writes and edits code, runs tests in a sandbox, browses the web, and opens a pull request for human review. Common uses are fixing GitHub issues, resolving bugs same-day, migrating legacy code, generating tests and docs, and running parallel agent fleets for dependency bumps or CVE remediation across many repos.

How is OpenHands different from Devin?

OpenHands is the open-source, self-hosted alternative to Devin. Both run the same autonomous "agent completes the ticket" loop, but OpenHands is MIT-licensed, model-agnostic (bring Claude, GPT, Gemini or a local model), and free to run — Devin is a managed commercial product on a per-seat subscription with vendor-locked infrastructure. OpenHands wins on cost and freedom; Devin wins on polished UX and managed reliability.

How is OpenHands different from Claude Code?

Claude Code is a CLI coding agent locked to Anthropic models, run locally in your terminal with a mature, first-party UX. OpenHands is a web-UI autonomous agent that is model-agnostic, runs in a sandboxed Docker/K8s container, and is built for unattended end-to-end task completion (it opens the PR for you). Use Claude Code for interactive terminal work; use OpenHands when you want to delegate whole issues to a self-hosted agent.

What models does OpenHands support?

Any LLM with tool-calling: Anthropic Claude, OpenAI GPT, Google Gemini, and open-weight models (Llama, Qwen) via any OpenAI-compatible endpoint or litellm. Local models run through Ollama keep your code fully on-premises. The OpenHands Index benchmarks rank models on agentic SWE performance so you can pick the best price/quality mix; the common pattern is Claude Opus for hard tasks and a cheaper model for routine steps.

Is OpenHands safe? Does it sandbox the agent?

Yes. Every agent runs in an isolated Docker or Kubernetes container with its own filesystem, shell, browser and editor — it cannot touch your host machine or other projects. Fine-grained access controls decide what the agent may do, and every action is logged and replayable (event-sourced). For regulated teams, the enterprise build deploys inside your own VPC so source code never leaves your perimeter.

Can I run OpenHands locally or self-host it?

Yes. The standard local install is `npx @openhands/agent-canvas` (or `npm install -g @openhands/agent-canvas` then `agent-canvas`), which opens Agent Canvas at http://localhost:8000. Add your LLM key in Settings > LLM Profiles. A Docker-only path is also available: `docker run -p 8000:8000 -v ~/.openhands:/home/openhands/.openhands -v ~/projects:/projects ghcr.io/openhands/agent-canvas:latest`. For organizations, OpenHands offers a self-hosted Kubernetes deployment with RBAC, audit logging and an Agent Control Plane for orchestrating fleets of agents across repositories.

What is OpenHands' SWE-bench score?

OpenHands scores roughly 70-77% on SWE-bench Verified in full autonomous mode, depending on the underlying model — about 72% with Claude Opus 4.6, among the top results for any open-source coding agent. Open-weight models via OpenHands come within 2-6 points of frontier models, so you can get near-state-of-the-art autonomy while keeping code on-premises.

Does OpenHands have a CLI?

Yes. OpenHands ships a layered interface: a composable Python SDK for building agents in code, a CLI that feels familiar to Claude Code / Codex users, a browser-based GUI (React + REST API) for watching and guiding agents, and a REST/WebSocket API for remote control and the hosted Cloud. You pick the surface that fits the job — script it, type it, or click it.

How much does OpenHands cost to run per month?

The software is $0 (MIT) and self-hosting has no conversation limit, so your bill is model tokens plus your own infrastructure. Community-reported token spend is roughly $5-15/month for daily bug-fixing on budget models (DeepSeek, Gemini Flash), $50-200+ for heavy frontier-model refactors, and $0 in tokens if you run local models via Ollama (you pay in GPU time instead). Add the compute you run the sandbox on — that is the line item no managed agent shows you, because there you are renting it.

Is the OpenHands Cloud free tier actually free?

Yes, with one hard limit: the hosted Individual tier is free for one user but capped at 10 conversations per day, versus unlimited conversations when you run the open-source build yourself. It includes cloud access from desktop and mobile, API access, Jira and Slack integrations, and either your own model keys or OpenHands-hosted models billed at cost with no markup — there is no credit system. Above Individual the official pricing page lists no team plan at all: the next step is Enterprise, which is custom-priced.

What does OpenHands Enterprise cost?

Nobody outside a sales conversation knows — the official pricing page publishes no number for Enterprise, only "custom pricing". What it adds is what an organisation needs to run agent fleets: SAML/SSO, unlimited users, multi-user RBAC, unlimited concurrent conversations per user, the Large Codebase SDK, Cloud Agent SDK, MCP support, secrets management, centralised team billing, priority support with a shared Slack channel and a named customer engineer, deployable as SaaS or self-hosted inside your own VPC. Treat it as a procurement cycle, not a price list.