OpenHands on AWS - A Coding Agent That Runs Where Your Code Already Lives
Hosted AI coding assistants are convenient right up until you think about what you just did: handed your repository, and often your API keys, to a third party's servers so a chatbot could open a pull request. For a side project that's a fair trade. For anything under an NDA, a compliance obligation, or just a healthy amount of paranoia about where source code ends up, it isn't.
Meetrix packaged OpenHands into an AWS Marketplace CloudFormation stack that deploys to a single EC2 instance inside your own AWS account. Pre-hardened Ubuntu 26.04 base image, Docker already installed, nginx and SSL configured, daily backups to S3 from day one. There's no software license fee either, you only pay the standard AWS hourly rate for whatever instance size you pick. Ready to try it? Launch the Meetrix OpenHands stack on AWS Marketplace.
What Is OpenHands?
OpenHands is an open-source, MIT-licensed project that describes itself as a self-hosted developer control center for coding agents, the kind of framing that matters because it's honest about scope. It's not just a chatbot that suggests code. Point it at a task and the default OpenHands agent can plan the work, write the change, run it, test it, and open a pull request end to end.
It isn't locked to its own agent, either. Claude Code, Codex, Gemini, or any agent that speaks the Agent-Client Protocol can run through the same interface, so you're not stuck picking one agent brand and living with it. Every conversation gets its own isolated container, which is a meaningfully different security posture from a single shared sandbox that every task funnels through. And automations can trigger on a schedule or a webhook, wired into Slack, GitHub, or Linear, for the kind of routine engineering work nobody wants to remember to kick off manually.
Worth Knowing Before You Deploy
How Deployment Works
Setting this up by hand means provisioning an EC2 instance, installing Docker, wiring nginx with a reverse proxy and certbot for SSL, and scripting your own S3 backup job before an agent ever touches a line of code. Through the Marketplace, it's four steps:
- Subscribe and Launch from AWS Marketplace Open the Meetrix OpenHands listing, subscribe, and launch the CloudFormation stack. t3a.medium is the recommended instance size, though a t2.micro qualifying for AWS's free tier works fine to kick the tires first.
- SSL, Reverse Proxy, and Backups Are Already Configured The stack sets up nginx in front of the instance with an automatic Let's Encrypt certificate, and schedules daily backups to an S3 bucket in your own account, all before you've opened a terminal.
- Wait for Boot, Then Open the Dashboard Give the instance a few minutes to finish starting, then open the dashboard over HTTPS at the domain or IP from the stack outputs.
- Connect Your LLM Provider and Start a Conversation Add your own Anthropic, OpenAI, or compatible API key. There's no default model bundled in, you pick, and you pay that provider directly.
What Meetrix Brings to This Deployment
- No Manual Docker or nginx Setup - The base image ships pre-hardened on Ubuntu 26.04 with Docker already installed and the reverse proxy wired up, not a checklist to work through before the agent will even boot.
- SSL Configured From the Start - Automatic Let's Encrypt certificates through the bundled nginx setup, so the dashboard is on HTTPS the moment DNS resolves.
- Isolated Sandboxes, Not a Shared Runtime - Each conversation runs in its own container. A misbehaving command in one session doesn't leak into another.
- Backups Running by Default - Daily automated backups to S3, protecting conversation and configuration state from the moment the stack finishes.
- No Software License Fee - Pricing runs purely on the AWS hourly rate for your chosen instance, from $0.001/hour on a t2.micro up to $0.029/hour on a c5.xlarge, with nothing added on top by Meetrix.
- People Who Actually Run This Stack - Support goes to aws@meetrix.io with a response inside 12 hours, from engineers who deploy this AMI regularly, not a queue reading from a script.
Who Is OpenHands on AWS Right For?
This fits teams that want an always-on coding agent without handing a third party their repository. More specifically, it's a strong match if you're:
- A dev team that wants a coding agent running against real infrastructure, not a hosted sandbox with its own idea of what your repo looks like
- An engineering org under NDA or compliance review that needs source code and API keys to stay inside its own AWS account
- A team already using Claude Code, Codex, or Gemini that wants one control plane instead of juggling separate CLIs and separate billing
- Someone automating routine engineering chores, issue triage, recurring reports, through Slack, GitHub, or Linear webhooks instead of doing it by hand every sprint
- A developer who wants isolated per-conversation sandboxing, so testing an agent on a risky task doesn't put every other session at risk
- Anyone who priced out a hosted AI coding assistant's per-seat plan and wants to know what the same category of tool costs without the markup
OpenHands on AWS by Meetrix vs Alternatives
| Feature | OpenHands on AWS by Meetrix | Devin (Cognition) | GitHub Copilot | Self-Managed Install |
|---|---|---|---|---|
| Hosting | Your own AWS account, fully self-hosted | Cognition's cloud, no self-host option | GitHub/Microsoft's cloud, no self-host option | Your own server, set up by you |
| License | MIT, fully open source | Proprietary | Proprietary | Open source, but you own every step of running it |
| Pricing Model | AWS instance rate from $0.001/hr, no software fee, your own model cost | $20/month Core plan plus $2.25 per ACU (roughly 15 minutes of agent work), Team at $500/month for 250 ACUs | $10-$100/user/month individual tiers, $19-$39/seat for Business/Enterprise, agentic usage metered against a monthly credit allowance | Server cost plus your own model cost |
| Agent Choice | OpenHands, Claude Code, Codex, Gemini, or any ACP agent, one interface | Locked to Devin, Cognition's own agent | Locked to Copilot's own agent and models | Whatever you wire up yourself |
| Sandboxing | Isolated container per conversation, on your own instance | Cognition-hosted sandbox VMs, opaque from the outside | Runs inside your editor or CI, no dedicated per-task sandbox | Yes, if you build and maintain it yourself |
| Deployment Time | Minutes via CloudFormation | Instant signup, but no self-host option | Instant, plugin install | Half a day or more, Docker, nginx, SSL, backups |
| Data Location | Your own AWS account | Cognition's infrastructure | GitHub/Microsoft's infrastructure | Your server |
| Support | Meetrix engineers, response inside 12 hours | Support tiers, gated by plan | Support tiers, gated by plan | Community forums only |
Resources
Under the Hood
Here's what's actually running once the stack finishes deploying.
Docker, Pre-Installed
The base image ships on a pre-hardened Ubuntu 26.04 with Docker already installed, since every conversation's sandbox is itself a container.
One Container Per Conversation
Each conversation gets its own isolated container rather than sharing a single runtime, so file edits and shell commands from one task don't cross into another.
nginx With Automatic SSL
nginx sits in front of the dashboard as a reverse proxy, with SSL issued automatically through Let's Encrypt once your domain resolves to the instance.
Not Locked to One Agent
The default OpenHands agent runs out of the box, but Claude Code, Codex, Gemini, and any Agent-Client Protocol agent can run through the same control plane.
Daily S3 Backups
Conversation and configuration state backs up daily to the S3 bucket you designate as a stack parameter, inside your own account, not Meetrix's.
Schedule or Webhook Triggered
Automations wired to Slack, GitHub, or Linear can run on a schedule or fire on a webhook, so recurring engineering work doesn't need someone to start it by hand.
One Thing OpenHands Won't Do For You
It won't review its own work for you. Isolated sandboxing keeps a runaway command from touching the host or another conversation, but it doesn't verify that the code an agent wrote is correct, secure, or something you'd actually want in production. The project itself is still tagged Beta, and no amount of container isolation substitutes for a human reading the diff before it merges. Treat the pull requests it opens the way you'd treat one from a fast, occasionally overconfident new hire, worth having, not worth rubber-stamping.
Frequently Asked Questions
What does OpenHands actually do?
It's a self-hosted control center for coding agents. Point it at a repo and it can plan a change, write the code, run it, test it, and open a pull request, without you babysitting every step. It runs the open-source OpenHands agent by default, but it isn't limited to that. Claude Code, Codex, Gemini, or anything else that speaks the Agent-Client Protocol can run through the same interface.
Do I need to bring my own LLM?
Yes. There's no bundled model access and no markup on top of it. Configure Anthropic, OpenAI, or any compatible provider after launch, and you're billed by that provider directly, at their published rate.
What does this cost to run on AWS?
There's no separate software license fee at all, just the AWS charge for whatever instance you pick. It scales from $0.001/hour on a t2.micro up through $0.024/hour on an r6i.large, r5.large, or c5a.large, to $0.029/hour on a c5.xlarge or c6a.xlarge. t3a.medium is the recommended starting point. On top of that, you pay your LLM provider for tokens, separately.
Is there a free trial?
The t2.micro tier qualifies for AWS's Legacy Free Tier, 750 free hours a month, so you can stand up the stack and poke around before committing to a larger instance. There's no refund policy beyond that, but you can cancel the subscription at any time.
Is it safe to let an AI agent run commands and edit files on my behalf?
Every conversation runs in its own isolated container, so an agent's file edits and shell commands stay scoped to that sandbox rather than touching the host directly or bleeding into a different conversation's workspace. That said, the agent still needs real credentials to open a PR or hit an API, so scope those credentials the way you would for any automation you didn't write yourself.
Can I connect this to Slack, GitHub, or Linear?
Yes. OpenHands supports automations triggered on a schedule or by webhook, wired into Slack, GitHub, and Linear, so routine work like issue triage or a recurring report can run without someone kicking it off by hand each time.
Is OpenHands finished software?
No, and it says so itself. The project currently carries a Beta tag in its own repository. It's under active development with a large, engaged community behind it, but treat it as a tool that's still evolving, not a finished product with zero rough edges.
Where does my code and data actually live?
On the EC2 instance inside your own AWS account, behind an nginx reverse proxy with automatic SSL. Meetrix doesn't have access to the running instance, your repositories, or your LLM provider keys once the stack is deployed. Backups run daily to an S3 bucket inside your own account.
Run Your Own Coding Agent on AWS
Stop handing your repository to a third party's servers. Deploy OpenHands on AWS in minutes, set up by a team that runs this stack every day.
Deploy on AWS Marketplace