OpenHands Pricing Explained: What You'll Actually Pay

OpenHands has roughly 76,000 GitHub stars and an $18.8M Series A, but the pricing model breaks every convention in the AI coding agent market — there’s no per-seat SaaS markup on the core product, and the free tier isn’t a time-limited trial. It’s a permanently free, model-gated entry point. If you’re evaluating autonomous coding agents and haven’t looked past the headline numbers, you’re missing the structural shift happening underneath.

The project, formerly known as OpenDevin, is an open-source autonomous software engineering agent built by All Hands AI. Rather than autocompleting inside your editor, it spins up sandboxed Docker environments, writes code, runs shell commands, browses the web, and opens pull requests end-to-end. It’s open-source under the MIT license and free to self-host, giving you full control over data and model choice. The platform is model-agnostic, supporting 100+ LLM providers including Claude, GPT, Gemini, and local models via Ollama.

Here’s what I find interesting: the July 2026 release cadence — Budgets dashboard, Agent Profiles, configurable BYOR key aliases — prioritizes operational control over raw horsepower. None of those features make the agent write better code. They make it safe to leave running unattended. That tells you where this product is heading, and it shapes everything about how you should think about the cost.

The Free Tier Isn’t What You Think It Is

The Individual cloud tier is free, capped at approximately 10 conversations per day, with LLM usage billed at-cost or via bring-your-own-key with no platform markup. That’s the surface-level description. The interesting part is what happened underneath.

In February 2026, OpenHands removed free credits for new cloud users via PR #12918, replacing them with free access to the MiniMax model on the Individual tier. The PR explicitly removed FREE_CREDIT_THRESHOLD and FREE_CREDIT_AMOUNT constants from the billing system and dropped the pending_free_credits column from the org model entirely.

This wasn’t a downgrade. It was a strategic masterstroke.

The old model gave you $20 in starting credits — a time-limited trial that expired. The new model gives you permanent access to a free model with capability limits. You start on MiniMax, hit its ceiling on complex tasks, and naturally upgrade to better models through OpenHands’ at-cost provider. The platform stays fee-free, but OpenHands captures your LLM spend once you outgrow the free tier. It converts a time-limited trial into a permanently free, model-gated entry point.

Multiple review sources still reference the $20 credits as if they’re current, which creates confusion. The GitHub PR is the source of truth here — it merged on February 18, 2026, and the release notes state plainly: “Free credits feature has been removed. Users can now try OpenHands Cloud for free using the Minimax model.”

What Each Tier Actually Costs

The pricing structure is genuinely different from every other tool in this space. There’s no per-seat subscription on the core product. Here’s the breakdown:

Plan	Price	What You Get
Open Source (self-host)	Free	MIT-licensed core, web GUI, CLI, model-agnostic, Git integrations
Individual (Cloud)	Free	Hosted cloud, ~10 conversations/day, BYOK or at-cost LLM with no markup
Cloud Pro	$20/month	Runtime compute, $20 one-time cloud credits, at-cost LLM usage
Enterprise	Custom (seat-based)	Private VPC or self-hosted, SSO, audit logs, unlimited concurrent conversations

The Cloud Pro subscription costs $20 per month, covering runtime compute and including $20 in one-time cloud credits, with LLM usage billed at-cost. Enterprise pricing is custom and seat-based for both SaaS and self-hosted deployments.

Here’s where it gets important for team planning: a 50-developer deployment cost cannot be projected from available pricing data. While Cloud Pro is listed at $20/month and Enterprise is seat-based, no source explicitly states per-seat pricing for team tiers, and Enterprise pricing is custom. You’ll need to contact sales for real numbers. Don’t let anyone give you a back-of-napkin estimate — the data doesn’t support it.

When you use the OpenHands LLM provider on Cloud Pro, you pay Anthropic/OpenAI rates directly with zero markup. Some developers report that Claude Sonnet 4.5 runs $3 per 1M input and $15 per 1M output tokens — the same rate as calling the API yourself. That cost transparency is the core differentiator. You’re not paying a platform markup on tokens. You’re paying for infrastructure and governance, with LLM spend flowing through at provider rates.

This is structurally different from tools like Devin, which bundles everything into a per-seat subscription. If you want a deeper comparison on that front, our OpenHands vs Claude Code analysis breaks down the real costs and tradeoffs between open-source and managed approaches.

The Governance Layer Capture Pattern

Here’s the pattern I’ve observed: OpenHands is undergoing a strategic pivot from open-source agent runtime to enterprise governance layer. The MIT-licensed core — sandboxed execution, CodeAct architecture, model abstraction — is being commoditized to drive adoption. The commercial value concentrates in the Agent Control Plane, Budgets dashboard, and RBAC. These features don’t improve agent capability. They make it safe to run at scale.

The evidence is in the release cadence. OpenHands v1.11.0 shipped July 9, 2026, and the headline features were a Budgets dashboard, Agent Profiles, and configurable BYOR key aliases. All operational control. Zero raw horsepower improvements. The architectural separation between the open-source core and the source-available enterprise/ directory makes this explicit — the open core is the adoption engine, the enterprise directory is the revenue engine.

The Agent Control Plane, launched May 6, 2026, is the clearest expression of this strategy. It provides centralized management for agent fleets — workflow definitions, lifecycle management, least-privilege access controls, sandboxed execution with full audit logging, and cost attribution per workflow. Running a single agent is straightforward. Running hundreds across an organization requires a system, and that system is what OpenHands is selling to enterprises.

This matters for your pricing analysis because it tells you where costs will concentrate over time. The agent itself is free. The LLM spend is at-cost. What you’ll pay for at scale is the governance layer — the thing that makes a fleet of autonomous agents safe enough to let loose on your production codebase. For a related look at how Microsoft approaches this same dynamic, our piece on agent lifecycle management costs traces how governance fees become the dominant cost line item.

SWE-Bench Performance and Model-Dependent Cost Variance

The benchmark numbers tell a story about cost that most pricing analyses miss. OpenHands scored approximately 53% on SWE-bench Verified using Claude 3.5 Sonnet in the April 2025 evaluation. That’s a solid number for an open-source tool. But it’s not the whole picture.

With Claude Sonnet 4.5 and extended thinking, that score jumps to 72.8%. With GPT-5 at reasoning=high, it hits 68.8%. Even Qwen3 Coder 480B reaches 65.2%. The performance variance between models is dramatic — nearly 20 percentage points between the weakest and strongest configurations.

Here’s why that matters for your budget: the free MiniMax model on the Individual tier will handle straightforward bug fixes and well-scoped tasks. The moment you point the agent at a complex issue — something requiring multi-step reasoning, cross-file refactoring, or deep codebase understanding — you’ll need a frontier model. And frontier models cost real money per token.

The tradeoff is clear: model-agnostic flexibility gives you 100+ providers to choose from, but the best results are locked to frontier models like Claude and GPT-5. You’re not paying a platform markup, but you’re paying provider rates for the models that actually perform well. The cost transparency is genuine. The cost predictability is not.

This is the same structural tension we see across the coding agent market. Our analysis of OpenAI Codex pricing found that the $20 Plus tier functions as a short-term trial rather than a sustainable plan, with most regular users needing the Pro tier to avoid excessive overage fees. OpenHands avoids the subscription markup but transfers the same cost variance to you through raw token spend.

Setup Complexity: The Hidden Cost

The pricing page says free. The reality includes infrastructure setup time that varies dramatically depending on your deployment path.

For an individual developer, installing Docker and running the initial setup takes about 10-15 minutes, and connecting GitHub can be done in under 30 minutes. The SaaS Individual plan requires no setup at all — just sign up and connect a repo. That’s the frictionless path.

Self-hosting tells a different story. Multiple sources flag complex setup compared to commercial alternatives like Devin as a genuine limitation. The Docker sandbox consumes significant CPU and memory, which may require dedicated hardware for concurrent sessions. Setting up the enterprise self-hosted instance with SSO and RBAC may take a full day.

The V0 to V1 SDK split in November 2025 adds another wrinkle. A substantial portion of community tutorials and third-party guides describe the V0 architecture, which is a different codebase. If a setup article doesn’t reference V1 or the Software Agent SDK, treat it as outdated. You’ll waste time following instructions that no longer apply.

Here’s the honest tradeoff: you’re choosing between operational convenience and self-hosting control. The managed cloud tier eliminates infrastructure overhead but caps you at 10 conversations per day on the free plan. Self-hosting gives you unlimited conversations and full data control, but you own the infrastructure cost, the setup time, and the maintenance burden.

The $18.8M Bet Isn’t on the Agent

OpenHands raised $18.8M in Series A funding in November 2025 led by Madrona, following a $5M seed round. Here’s what that money is actually betting on.

The open-core model is a smarter commercial strategy than Devin’s pure SaaS approach because it weaponizes community trust to drive adoption, then monetizes the compliance and cost-control layer that enterprises will pay for regardless of which LLM powers the agent. The agent is interchangeable — swap Claude for GPT-5 for Gemini, and OpenHands still runs. The control plane around the agent is where the moat lives.

The July 2026 release themes confirm this. Budgets, agent profiles, reliability, encrypted MCP credentials, enterprise BYOR configurability — the roadmap reads as making OpenHands Cloud dependable and affordable to run at scale. Less headline capability, more of the durability and cost-control layer that makes an agent platform trustworthy in production.

For you, that means the pricing model will likely stay favorable on the core product. The open-source MIT core will remain free. The cloud Individual tier will remain free. LLM usage will remain at-cost with no markup. What will cost money — real money, custom-priced enterprise money — is the governance layer that makes this safe for a 500-engineer organization with compliance requirements and audit trails.

Decision Framework: Where OpenHands Makes Sense

The right choice depends on your team’s size, codebase maturity, and tolerance for workflow disruption. Here’s how the tradeoffs break down:

Choose self-hosted open source if you have infrastructure expertise, data residency requirements, and want zero recurring platform costs. You pay only for LLM API calls through your own keys. You own the setup time and maintenance overhead.

Choose Cloud Individual if you’re a solo developer or small team wanting to test the waters. The free tier with MiniMax gives you permanent access without a credit card. You’ll hit capability limits on complex tasks and need to supply your own API keys for frontier models.

Choose Cloud Pro if you need managed runtime compute, GitHub/GitLab/Bitbucket integrations, and want the $20 one-time credits for initial LLM spend. The $20/month covers infrastructure — your LLM costs are still at-cost with no markup.

Choose Enterprise if you need private VPC deployment, SSO, audit logs, RBAC, unlimited concurrent conversations, and the Agent Control Plane for managing agent fleets at scale. Pricing is custom and seat-based. You’ll need to talk to sales.

The question worth asking before you commit: does your team have the discipline to monitor token spend, or do you need pre-built budget controls? If the answer is the latter, the Enterprise tier’s cost-control features aren’t a luxury — they’re the insurance policy that prevents a runaway agent loop from burning through your LLM budget overnight. And that’s the real pricing story here: the agent is free, the models are at-cost, but the governance that keeps them from bankrupting you is what you’ll eventually pay for.

The open question is whether OpenHands can execute the governance layer fast enough to capture enterprise spend before competitors build equivalent controls. The July 2026 release cadence suggests they’re aware of the race. Whether they win it depends on execution, not architecture.