OpenHands Cloud pricing: what do I get on the free tier vs the $20/month subscription?

Quick Answer: The OpenHands Cloud free tier gives you a full, hosted agent runtime with core integrations and BYOK support for a single user, while the $20/month subscription unlocks higher usage limits, access to OpenHands’ at-cost models, more automation surfaces (APIs, ticketing integrations), and support options that make it viable for sustained team workflows.

The choice between the free tier and the $20/month plan comes down to how deeply you want to wire OpenHands Cloud into your SDLC. The free tier is ideal to validate the runtime, test agents against your repos, and prove out workflows. The paid plan is built for engineers who want to move from “trying an agent in the browser” to “reliable automation across Git, tickets, and CI”—with higher capacity, more integrations, and support when something breaks in production.

Key Benefits:

• Validate the platform with zero friction: Use the free tier to run real agents against your own codebases, BYO model keys, and see if the runtime fits your security and workflow constraints.
• Scale to real workloads at $20/month: Unlock higher token throughput, hosted APIs for automation, and ticketing/Git integrations so agents can process a steady stream of issues and PRs.
• Stay in control of models and costs: On both tiers you can bring your own LLM keys; on the paid tier you can also use OpenHands’ managed model access at-cost, without getting locked into a single provider.

---

Why This Matters

Agent platforms live or die on two axes: runtime trust and integration depth. It’s not enough to have an “AI assistant” that can edit a file; you need a secure, observable runtime that can take work from GitHub/Jira/Slack, generate reviewable artifacts (PRs, diffs, tests, release notes), and run at the scale your backlog demands.

OpenHands Cloud pricing is structured so you can:

• Start on the free tier to test the model-agnostic, sandboxed runtime in your environment.
• Upgrade to $20/month when you’re ready to wire agents into ticket queues and CI.
• Keep model choice and data boundaries (BYOK, private deployments later) without changing platforms.

For most teams, the path looks like: free tier to validate, $20/month to operationalize, and Enterprise for VPC/self-host when compliance demands full isolation.

---

Core Concepts & Key Points

Concept	Definition	Why it's important
OpenHands Cloud	SaaS-hosted version of OpenHands with a managed sandbox runtime, integrations, and optional at-cost models.	Lets you run cloud coding agents without managing infrastructure, while keeping visibility into every run and artifact.
Free Individual Tier	No-cost plan for a single user with hosted runtime, Git integrations, and BYO LLM keys.	Ideal for pilots and solo engineers to prove value on real repos before committing budget.
$20/month Subscription	Paid individual/business plan with higher usage, Cloud APIs, ticketing (e.g., Jira) and Slack integrations, and at-cost models.	Designed to handle sustained workloads, integrate with your SDLC tools, and support automation beyond ad hoc runs.

---

How It Works (Step-by-Step)

At a high level, OpenHands Cloud pricing is tiered by: where it runs, who it’s for, and how deeply you integrate it into your pipelines.

1. Free Tier: Prove Out the Runtime

On the free OpenHands Cloud tier you get:

• Hosted agent runtime:

  • Run agents from a browser-based Web GUI.
  • No local Docker/Kubernetes setup needed.
  • Good for: exploring the platform, running agents against small-to-medium repos, validating sandbox behavior.

• Model choice via BYOK:

  • Bring your own LLM keys from providers like Anthropic, OpenAI, or Bedrock.
  • You keep direct control over model selection, spend, and data processing agreements.

• Core Git provider integrations (Cloud):

  • Connect to GitHub/GitLab to:
    • Summarize pull requests.
    • Apply review feedback.
    • Generate tests and fix failing ones.
    • Open PRs with dependency/security upgrades.
  • All run inside OpenHands’ managed containerized sandbox.

• Core platform features, constrained by limits:

  • Single-user orientation.
  • Reasonable caps on concurrent runs, token throughput, and repo size so you can evaluate real workflows without cost.
  • Access to the same “open, observable, sandboxed” model as higher tiers—just with lower ceilings.

The free tier is not a toy. It’s the same core agent runtime and observability primitives, but sized for validation and solo use.

2. $20/month Subscription: Operationalize Agents

When you move to the $20/month OpenHands Cloud plan, you’re effectively saying: “We want this wired into our SDLC, not just in a browser tab.”

In addition to everything in the free tier, you get:

• Higher usage and concurrency:

  • More agent runs and higher token allowances.
  • Practical for daily use across multiple repos and backlogs.
  • Less likely to hit rate limits when running longer refactors, repo-wide upgrades, or multiple parallel tasks.

• Cloud APIs for automation and scripting:

  • Use hosted Cloud APIs to:
    • Trigger agents from CI/CD or cron jobs.
    • Orchestrate multi-step workflows from your own services via the SDK.
    • Run agents “headlessly” on schedules (e.g., nightly dependency scans, weekly test gap detection).
  • This is where OpenHands transitions from “UI product” to “automation runtime you can call.”

• Jira and Slack integrations:

  • Jira:
    • Turn issues into PRs that fix bugs, upgrade dependencies, or fill test gaps.
    • Auto-generate descriptions and link back to Jira for auditability.
  • Slack:
    • Delegate tasks from the surfaces engineers already live in.
    • Monitor agent runs and share results in channel for collaborative review.

• BYOK or use OpenHands models at-cost:

  • Continue using your own LLM keys, or:
  • Use OpenHands’ pre-integrated models and pay at-cost through OpenHands.
  • This matters if procurement prefers a single billing channel or you want to benchmark multiple models without separate contracts.

• Support and reliability for real workloads:

  • Ticket-based support is included so you’re not debugging your automation alone.
  • You’re running the same core platform trusted by engineers at AMD, TikTok, VMware, Roche, Amazon, Netflix, and more—just sized for individual/business use.

Day-to-day, the $20/month tier is the line between “I can experiment and run some PR automation” and “I can treat this as a reliable, integrated agent layer across my codebase and ticket queues.”

3. Enterprise: VPC, SSO, and Org-Scale Governance (For Context)

You asked about free vs $20/month, but it’s useful to know where Enterprise fits:

• Deploy SaaS or self-hosted in your VPC.
• Enterprise SAML/SSO and RBAC for fine-grained access control.
• Unlimited concurrent conversations per user and a Large Codebase SDK for very large monorepos and complex orchestration.
• Named customer engineer, shared Slack channel, and dedicated support.

If you’re starting on free or $20/month, this is the eventual landing zone when security teams demand private cloud/self-host with full governance.

---

Common Mistakes to Avoid

• Treating the free tier as “just a demo”:
  The free tier is fully capable of running real engineering work. Don’t just summarize random files—connect your actual repos, run PR-generating tasks, and validate sandbox behavior, logs, and diffs.

• Upgrading before you test your workflow shape:
  Instead of upgrading immediately, use the free tier to answer: Which repos? Which ticket flows? Which CI hooks? Then move to $20/month with a concrete plan for API usage, Slack/Jira wiring, and model selection.

---

Real-World Example

A small platform team wants to reduce time spent on dependency upgrades and flaky tests.

1. On the free tier, they:

   • Connect a staging GitHub org.
   • Use the Web GUI to run OpenHands agents that:
     • Scan for outdated dependencies.
     • Open PRs with upgraded versions and generated tests.
   • Validate that every agent run is:
     • Visible (full logs).
     • Reviewable (clear diffs).
     • Repeatable (they can re-run the same task deterministically if CI fails).

2. After a week, they see real PRs landing and decide to expand:

   • They upgrade to the $20/month plan so they can:
     • Use Cloud APIs to trigger agents from their CI system whenever a new vulnerability is published.
     • Wire Jira so “dependency upgrade” tickets auto-generate draft PRs.
     • Use Slack to monitor runs and share results directly with the feature teams that own each service.

Now, instead of manually triaging dependencies and flaky tests, the team has a repeatable, auditable agentic workflow—and they did the risk assessment on the free tier before spending the $20/month.

Pro Tip: On the free tier, design the exact workflow you plan to automate—end-to-end from Git/Jira/Slack to PRs and CI—and keep a list of what you wish were “just a webhook call.” That list becomes your immediate API automation backlog once you upgrade to the $20/month plan.

---

Summary

The free OpenHands Cloud tier is your low-friction way to validate the platform’s core thesis: open, model-agnostic agents running in a secure, observable runtime that produces reviewable engineering artifacts. You get BYOK model support, hosted Web access, and Git integrations suitable for serious pilots and solo work.

The $20/month OpenHands Cloud plan is for when you’re ready to operationalize that same runtime: higher usage ceilings, Cloud APIs for automation, Jira and Slack integrations, and the option to use OpenHands models at-cost. It’s the step from “this works in a browser” to “this is a stable automation layer in our SDLC.”

If you expect to run agents regularly against live repos, trigger them from tickets or CI, or centralize model access, the $20/month tier is usually the right default.

---

Next Step

Get Started