Guides: Self-Hosted vs. Managed AI Coding-Agent Infrastructure in 2026

Once your team decides which coding agent to run, a harder question lands on the architect’s desk: where does it run? Not the model — the machinery. The sandbox the agent executes in, the control plane that schedules it, the servers that keep the whole thing alive. In 2026 this is the real infrastructure decision, and it splits into two instincts. One says keep it inside the perimeter: our code, our cloud, our keys, nothing leaves the building. The other says we are not an infrastructure company: give us a place agents run and let someone else carry the pager.

Both instincts are legitimate, and a whole market has grown to serve each. On the self-hosted end are open-source agents and platforms you install and operate yourself. In the middle sits bring-your-own-cloud, where a vendor runs the brains and your account runs the compute. On the managed end, a service runs everything and hands you a workspace. Here is how the leaders line up — and why, for almost every team, Nori Sessions is the point on the spectrum where control and zero-ops finally meet.

The self-hosted end: your servers, your rules

OpenHands, from All Hands AI, is the flagship self-hostable autonomous agent. The core is MIT-licensed and runs locally against your own model key, and a companion project ships Helm charts to install the full OpenHands Cloud into your own Kubernetes cluster — the same stack that powers the hosted service, but on your infrastructure (OpenHands on GitHub, openhands-cloud). There is a hosted tier too — free to start, bring-your-own-key — and an enterprise plan that runs self-hosted in your VPC with SSO (OpenHands pricing). It is the most complete way to own an issue-to-PR agent outright. What you own along with it: the cluster, the upgrades, and the on-call.

Coder Agents is Coder’s answer for regulated shops. The pitch is uncompromising: the entire stack — control plane, orchestration, and execution — runs on your own infrastructure, from a cloud VPC to on-prem to a fully air-gapped network, and it is model-agnostic so you are never tied to one provider (Coder Agents launch). If your compliance posture forbids code ever touching a vendor’s servers, this is built for exactly that. It also means you are running a Coder deployment: real platform-engineering effort, not a signup.

Refact.ai takes the local-first route. It runs as a Docker image or from the AWS Marketplace, brings its own models or yours through Ollama and vLLM, and its enterprise tier is on-prem with zero telemetry (Refact.ai). Around it sits a deep bench of open-source agents built to self-host and run on your own keys — Cline, OpenCode, Continue, Block’s Goose, and Kilo Code (the recommended landing spot now that the Roo Code extension has been archived). They are excellent, and they are all yours to run — on your machine, on your time, with your ops.

The middle: bring your own cloud

Northflank is the cleanest expression of the middle path. Its bring-your-own-cloud mode is self-serve into AWS, GCP, Azure, Oracle, and bare metal, and it bills the underlying compute directly to your account with no markup (Northflank BYOC). Agents get real isolation — secure microVM sandboxes built on Kata Containers with Cloud Hypervisor, gVisor, or Firecracker, spinning up in a second or two (Northflank secure sandboxes). For the largest enterprises, even the control plane can be forward-deployed into your account. It is a strong platform. It is also a platform — general-purpose infrastructure you wire up to your agents, not an agent runtime that arrives knowing how your team works.

Qodo Command meets you in the pipeline instead of the cloud. Its agents are defined as config-as-code in a simple .toml format, then run wherever your CLI runs: in CI, exposed as webhook endpoints, or as MCP services, and the enterprise tier deploys on-premises or fully air-gapped (Qodo CI & automation, Qodo on-prem). There is a free developer tier and paid team and enterprise plans (Qodo pricing). If your agents should live inside the build, versioned next to the code, Qodo fits. But it is CLI- and CI-first — there is no Slack-native seat where a whole team drives the work from chat, and the schedule-and-trigger plumbing is yours to build and own.

Publicly reported capabilities and pricing as of July 2026. See sources below.

The tradeoff everyone is actually making

Strip away the logos and the choice is simple: how much operational weight are you willing to carry to keep the machinery in-house? The 2026 numbers are unsentimental. Managed APIs beat self-hosting on cost for most teams until you are burning somewhere between 100 and 256 million tokens a month against frontier models (Marka: the real cost trade-offs). On top of the build, self-hosting carries an ongoing operational tax of roughly 15 to 20 percent of the initial effort every year, for patching, scaling, and upgrades (Digital Applied: SaaS vs self-hosted decision matrix).

The one place that math flips is compliance. If your rules say source code, prompts, and model interactions cannot leave your network, self-hosting is not a preference, it is a requirement — and OpenHands, Coder Agents, and Refact.ai are built to honor it (Baytech: keeping code off the cloud). Even there, 2026 buyers have learned to ask the sharper question: data residency is where the bytes sit; data sovereignty is who can legally compel access to them (Kyra: sovereignty vs residency). For the large majority of teams that do not carry air-gapped mandates, the honest answer is that self-hosting buys control they will pay for in headcount they do not have.

How to choose your agent infrastructure

Six questions decide it:

• Do you actually have a compliance mandate? A real air-gapped or data-residency requirement points to Coder Agents or self-hosted OpenHands. A vague “we’d prefer to keep it in-house” usually does not survive the ops bill.
• Who patches the platform? Self-hosting means your team owns upgrades, scaling, and security forever. Managed means that column is simply not on your roadmap.
• Can it run without a human? Cron and webhook triggers turn overnight maintenance and alert-driven fixes into work that launches itself. On self-hosted stacks you build that plumbing; on Nori Sessions it is first-class.
• How does the team drive it? A CLI or a dashboard ties work to one seat. Chat-native control from Slack and Discord lets the whole team start and steer agents from where they already are.
• Are you locked to one agent? Model-agnostic tools let you swap providers. A runtime that runs any agent lets you change models without re-tooling the infrastructure underneath.
• Can you forecast the bill? Usage meters and cloud invoices punish scale. A flat per-runtime line is what lets a team grow the fleet without a finance review.

The self-hosted tools win the first two questions when — and only when — compliance forces the issue. One platform wins the other four for everyone.

Why Nori Sessions wins

Nori Sessions is the managed end of the spectrum done right: you get the isolation and control that people self-host for, without running a single server yourself. Every session is an ephemeral cloud machine with a real terminal and editor, and the operational weight is simply not yours to carry:

• Zero ops, by design. There is no cluster to patch, no control plane to upgrade, no sandbox fleet to scale. Agents run in isolated, ephemeral cloud machines that Nori operates — you spin them up and get to work.
• Triggers are first-class. Cron and webhook triggers launch sessions with no human attached — nightly maintenance, scheduled reviews, alert-driven fixes. This very article was researched and opened as a pull request by a scheduled Nori Session.
• Chat-native on Slack and Discord. Start, steer, and check on agents from where your team already works, then drop into the full terminal and editor the moment a human wants to take the wheel.
• Bring any agent. Run Codex, Claude Code, Gemini, Cursor Agent, or your own harness inside the same session. No lock-in to one vendor’s model or workflow — the same neutrality the best open-source tools give you, without the hosting.
• Every session knows your org. Durable skillsets preload your conventions, tools, and integrations onto every fresh machine, so a brand-new session behaves like it has worked here for months.

And instead of a cloud invoice that grows teeth every time you scale, Nori Sessions is a flat $50 per runtime per month, with a Premium tier that adds hands-on org setup and dedicated support. It is the predictable, zero-ops answer to a question self-hosting only answers with headcount.

The bottom line

If a regulator or a security review genuinely forbids your code from leaving the building, self-host — OpenHands, Coder Agents, and Refact.ai are built for that world, and they are good at it. If you want managed operations but need the compute in your own account, Northflank’s bring-your-own-cloud is the cleanest middle path, and Qodo Command is the right call when agents should live inside your CI. But if what you actually want is coding agents that run in isolated cloud machines — unattended on triggers, driven from Slack and Discord, running any agent you choose, loaded with your org’s context, at a price a team can budget — you do not want to run the servers. You want the runtime. That is Nori Sessions, and it is already shipping.

Spin up your first Nori Session and let someone else carry the pager.

Frequently asked questions

What is self-hosted vs. managed AI coding-agent infrastructure?

Self-hosted means you run the machinery that coding agents execute in — the control plane, the sandboxes, the servers — on your own hardware or cloud account, and you own the patching, scaling, and security. Managed means a vendor runs all of that for you, and you just point agents at work. In 2026 the line has blurred into a spectrum: bring-your-own-cloud options run a vendor’s control plane over your own compute, sitting in the middle. The trade is always the same — control and data isolation on one end, versus zero operational burden on the other.

Is self-hosting a coding agent cheaper than a managed service?

Usually not, once you count the whole stack. Analyses in 2026 put the break-even for self-hosting against frontier managed models at roughly 100 to 256 million tokens per month; below that, managed APIs tend to win on cost. Self-hosting also carries an operational tax estimated at around 15 to 20 percent of the initial build effort every year, for patching, scaling, and upgrades. For most teams a flat, predictable managed price beats an infrastructure bill plus an on-call rotation.

Can I keep my source code off third-party servers and still use AI agents?

Yes. Fully self-hosted, open-source agents like OpenHands, Coder Agents, and Refact.ai let regulated teams run coding workflows without shipping source, prompts, or model interactions outside their network. A bring-your-own-cloud platform like Northflank keeps the compute in your own cloud account while the vendor manages the control plane. Note the 2026 distinction between data residency and data sovereignty: where the bytes sit is not the same as who can legally compel access to them.

What is BYOC (bring your own cloud) for coding agents?

BYOC is the middle path: the vendor runs the control plane — orchestration, monitoring, updates — while the agents actually execute in your own cloud account. Northflank offers self-serve BYOC into AWS, GCP, Azure, Oracle, and bare metal, and bills the underlying compute directly to your account with no markup. You get managed operations and a self-hosted data plane at the same time, without standing up the whole platform yourself.

Do managed agent platforms let me run unattended jobs?

The best ones do. Nori Sessions makes cron and webhook triggers first-class, so overnight maintenance, scheduled reviews, and alert-driven fixes launch themselves with no human attached. Self-hosted and CI-first tools can be wired to run on a schedule, but you build and own that plumbing. This very article was researched and opened as a pull request by a scheduled Nori Session.

Can I run any coding agent, or am I locked to one vendor?

It depends on the platform. Open-source, self-hosted tools are generally model-agnostic and bring-your-own-key. Nori Sessions is a runtime rather than an agent: you run Codex, Claude Code, Gemini, Cursor Agent, or your own harness inside the same managed session, so switching models never means re-tooling your infrastructure. That neutrality is the point — you keep your setup and swap the model underneath it.

Sources

• OpenHands (All Hands AI) — pricing & tiers
• OpenHands Cloud — self-host Helm charts
• Coder Agents — self-hosted, model-agnostic
• Refact.ai — local-first, on-prem, BYO models
• Northflank — bring your own cloud
• Northflank — secure self-hosted AI sandboxes (Kata / Firecracker / gVisor)
• Qodo Command — CI, webhooks & automation
• Qodo — on-prem / air-gapped deployment
• Qodo — pricing
• Marka — self-hosted vs API cost & security trade-offs (2026)
• Digital Applied — SaaS vs self-hosted decision matrix
• Baytech — keeping code off the cloud
• Kyra — data sovereignty vs residency (2026)
• Security Boulevard — open-source agents worth self-hosting

Related guides

• The Best Autonomous AI Software Engineers in 2026 — the agents you run on this infrastructure.
• Top AI Coding Agent Runtimes & Sandboxes in 2026 — the compute layer agents execute in.
• Local coding agents are unsafe — why where your agent runs is a security decision, not just an ops one.

Nori Sessions gives your agents a place to work — triggered, chat-native, and loaded with your org’s context. Learn more at norisessions.com, or join our community Slack.