Understanding Agent Hosting Pricing at the Entry Level

Entry-level agent hosting almost never means what the price tag says it means. The number on the pricing page covers compute, and compute is maybe half the actual cost of running an agent that works. Storage, orchestration, monitoring, and recovery all sit outside that sticker, and at the entry tier, those are exactly the pieces most likely to be missing without anyone telling you.

Most comparisons stop at compute because compute is the easy thing to compare. Dollars per hour, tokens per request, GPU seconds. But a production agent needs four layers working together, not one. Skip that and you end up with a bill that looks cheap in the spreadsheet and expensive in practice.

Consider a chatbot compared with an agent that does real work. A chatbot can run on ephemeral compute with no file persistence and nobody notices, because the conversation is the whole product. An agent that extracts a contract, writes a report, or commits code needs a place for that output to live between sessions. If the environment resets on every deploy, the agent's work resets with it. That's not a hosting nuance: an agent that produces something durable stands apart from one that produces nothing durable.

The market driving this conversation grew fast. The AI agents market hit $7.84 billion in 2025, with continued growth projected into 2026. A lot of that growth is organizations moving agents out of demo mode and into production, and that shift is exactly where the storage and coordination gaps appear. Nobody notices a missing orchestration layer during a prototype. They notice it the first time an agent crashes mid-task and there's no record of what it already finished.

Four layers to check on any platform, before price even enters the conversation:

Compute: running the model and executing the agent's business logic

Most platforms are strong on one or two of these and quiet about the rest. It's a structural fact about how entry-level tiers get built, not a knock on any single provider. It's a structural fact about how entry-level tiers get built: the cheap plan advertises the layer that's cheapest to provide, and the layers that cost the platform money to maintain get folded into a higher tier or left out.

Once you know what you actually need, the next question is which runtime you're hosting in the first place, because that choice shapes what "entry-level" even has to include.

The four runtimes most commonly hosted in 2026 and their actual purpose

Four agent runtimes dominate hosting conversations in 2026, and each one has a clear center of gravity, a place where it's genuinely good, rather than being a general-purpose tool that does everything equally well.

Claude Code, from Anthropic, is built for deep codebase work. It runs from the terminal, an IDE, a desktop app, or a browser, and its strength is understanding a repository well enough to edit files and run commands inside it correctly. Teams already built around Anthropic's models tend to reach for this first.

Codex, OpenAI's coding-tuned agent family, leans hard into the ChatGPT ecosystem. The "Sign in with ChatGPT" OAuth flow lets a user draw against an existing ChatGPT plan instead of metering every request against a separate API budget, which matters a lot if the team already pays for ChatGPT seats.

Hermes Agent is the open-source, self-improving agent from Nous Research, and it's a different animal entirely because it's persistent. It has memory, skills, a board-style task view for tracking work, and messaging gateways, and it's designed to keep running when nobody's at the keyboard. Since its Desktop App launched, Hermes has picked up more than 180,000 stars in under four months, making it the fastest-growing open-source agent framework of the year.

OpenClaw is shaped around flows rather than conversations. It runs durable TaskFlows with provenance-rich memory and structured human-approval gates, and its natural home is operations teams automating multi-step processes that need an audit trail. OpenClaw has passed 345,000 stars and currently holds the #1 daily global rank on OpenRouter by token volume.

The simplest way to tell them apart: Claude Code is what a developer opens on a laptop to write code. Hermes is what sits on a server, accepting messages while the developer is at lunch. OpenClaw is what an operations team runs when a process needs steps, approvals, and a record of who signed off on what.

These runtimes increasingly get combined rather than chosen between. Hermes can spawn Claude Code as a subagent to handle a coding task inside a longer workflow. OpenClaw flows can call out to Claude Code the same way. A lot of 2026 stacks run all three, each doing the part it's good at.

This matters for pricing because a runtime that runs persistently asks more of its hosting environment than one that only runs when someone opens it. Hermes and OpenClaw need to stay alive, keep state, and recover from failure without a human watching. Claude Code, run from a CLI, doesn't carry that same weight. That difference is exactly where entry-level hosting tiers start to diverge in what they include.

The sticker price of self-hosting and its hidden omissions

On paper, self-hosting looks cheap. A basic VPS capable of running an agent's orchestration layer runs $5 to $40 a month. Add a GPU for local inference and the range jumps to $200 to $1,000 a month for cloud GPU instances, or $5,000 to $30,000 upfront if buying dedicated hardware. Storage, networking, backups, and basic monitoring tack on another $20 to $200 a month. A 16 GiB memory-optimized DigitalOcean Droplet, for reference, lists at $84.00 a month, already above where a lot of managed plans start their entry tier.

None of that touches the cost of getting the thing running in the first place. Installing Docker, Postgres, Redis, Nginx, SSL certificates, firewall rules, and DNS takes four to six hours for someone who's done it before, and eight to twelve hours for someone who hasn't. At $75 to $150 an hour of engineering time, that adds up to a substantial sum spent before the agent completes a single task. And that's before configuring the actual agent framework: setting environment variables, wiring up OAuth integrations by hand, testing that everything talks to everything else.

Then there's the ongoing work nobody puts in a spreadsheet. Security patches. Framework updates. Dependency conflicts that break something unrelated. Disk space filling up. Log rotation. SSL certificates expiring on a Saturday. Incident response when the agent goes down, Postgres fills its disk, a Docker container crashes, or a memory leak slowly eats the box over three weeks. Agents connected to Gmail, Slack, or a CRM also need credential auditing and periodic review of what the agent's skills are actually doing with that access.

A 30-day total cost of ownership breakdown from betterclaw.io puts real numbers on this. Self-hosting an OpenClaw instance on a $24-a-month DigitalOcean droplet, with 8 hours of ops time billed at $75 an hour, is $651 a month in real terms. Not $24. That $651 figure uses the conservative end of engineering rates. Bump the hourly rate to $150, reasonable for a senior engineer or a founder doing the work themselves, and the total crosses $1,200.

None of this means self-hosting is a mistake. It means the sticker price and the actual cost are two different numbers, and entry-level comparisons almost always show the reader only one of them.

How managed platforms price entry-level hosting and what the tiers typically include

Managed hosting trades that operational overhead for a recurring fee, and the premium for doing so is real but bounded. Managed services typically add somewhere between 20% and 50% over the cost of renting raw GPU capacity, in exchange for someone else handling the ops work.

For a moderate-use managed deployment, the total monthly bill usually is between $100 and $800 all-in, with API and inference costs running separately, another $50 to $500 depending on which model tier is in use and how many requests the agent makes.

What "entry-level" actually includes varies more than the headline price suggests. The dimensions to check:

• Whether persistence is real (files and context carry across sessions) or ephemeral (wiped on redeploy)
• Whether monitoring and automatic recovery come with the base plan or sit behind a paywall
• Whether integrations like Gmail, Slack, and GitHub are built in, or require manual OAuth setup on the user's end
• Whether bringing your own API keys (BYOK) is possible at the entry tier or reserved for higher plans
• Whether security patching is handled by the platform or left to the customer

A few platforms illustrate how differently entry-level pricing can be structured. Railway runs on a credit-based model, typically $5 to $50 a month for an always-on service depending on resource use, with persistent volumes that survive restarts, though it has no native GPU support and will shut down an app once its credits run out. MyClaw's Scout plan, at $4.99 a month, packages 1 vCPU, 2 GB of RAM, 2 TB of bandwidth, and 50 GB of storage specifically for running OpenClaw and Hermes, with automated daily backups, managed SSL, and a firewall included, though LLM token costs are billed entirely separately.

The pattern holds across the board: compute pricing is disclosed clearly, right there on the page. Persistence, monitoring, and integrations are where entry-level tiers quietly differ from each other, and where the fine print matters more than the headline number.

Per-user sandboxing: the pricing model that changes when you're building a product, not running one agent

Everything above assumes one agent, doing one job, for one person. Building a product that runs an agent for every customer changes the math completely.

An agent sandbox is an isolated environment where an agent takes actions without touching the host system or any other user's environment. For a multi-tenant product, that isolation isn't optional. Each customer's sandbox needs its own state, its own disk, and persistence across turns, so context carries forward the next time that specific user comes back.

Most entry-level hosting tiers were never built for this. The requirements that show up once you're running a sandbox per customer instead of one server for yourself:

• Multi-tenant isolation, so one user's agent can't see or affect another's
• Pause and resume, with the ability to snapshot state
• Low or no cost when idle, so a dormant customer isn't running up unnecessary charges
• Events and metrics tracked per sandbox, not just for the whole system
• Fast sandbox provisioning, so a new user isn't delayed waiting for the environment to start

Pricing from the runtime providers themselves gives a sense of what this actually costs. OpenAI's Agents API, launched September 10, 2026, charges no fee of its own for the API, but its hosted sandbox bills $0.03 to $1.92 per 20 minutes depending on container tier, with sessions billed by the minute and a 5-minute minimum. Anthropic's Claude Managed Agents charge $0.08 per session-hour, plus $0.05 per container-hour for the code execution tool, with 1,550 free hours included and containers with up to 8 GB memory and 10 GB disk.

Per-minute billing, rather than per-session or a flat monthly rate, is the detail that makes this pricing model actually work at scale. It means paying for compute the agent is actually using. A 2 vCPU, 4 GB sandbox running continuously meters at around $4.76 a month, and drops to metering disk alone once it goes to sleep.

This is also what makes white-labeling a natural next step. The operator holds the API key, the end customer only ever sees the operator's own brand, and a new sandbox gets provisioned automatically the moment someone signs up, rather than a founder manually setting up infrastructure for every new user by hand.

Security and runtime risk at the entry level, including what's patched for you and what isn't

Security patching is one of the clearest places where the gap between managed and self-hosted becomes visible, and OpenClaw's record over 2026 makes the stakes concrete.

CVE-2026-25253 carried a CVSS score of 8.8. It allowed authentication token exfiltration that could lead to full Gateway compromise and remote code execution, and it was patched in January 2026. CVE-2026-32922 was worse on paper, a 9.9 out of a possible 10 on the CVSS scale: a caller with pairing permissions could mint operator.admin tokens for paired devices, potentially reaching remote code execution.

For anyone self-hosting, the real question is how fast the patch got applied, and whether anyone was even watching for the advisory in the first place. It's how fast it got applied, and whether anyone was even watching for the advisory in the first place.

Hermes takes a more cautious default posture. Its approval gates evaluate commands before they run, and production deployment guidance recommends running it inside Docker or a sandboxing platform, with dropped Linux capabilities and disabled privilege escalation.

Controls to look for on any platform, whether it's built in or something a self-hoster has to add:

• Time limits on agent execution to prevent runaway tasks
• Immutable audit logs covering every network request, shell command, and file write
• Outbound network access blocked by default, with an explicit allowlist for the APIs the agent actually needs
• Credentials handled as runtime configuration, never appearing in a prompt, an agent's instructions, or a committed file

The pricing implication is straightforward. A managed platform that patches a critical CVE within hours, and runs regular audits of what an agent's skills are doing, is absorbing a cost that a self-hoster otherwise pays in engineering time, and that cost spikes without warning the moment a high-severity vulnerability drops. Encryption in transit and at rest, along with documented security certifications, is the baseline worth checking for. A platform with no dedicated security page, no published compliance certification, and no documented incident response process leaves a buyer with no way to actually judge the risk they're taking on.

Reading an entry-level pricing page honestly: the questions to ask before you commit

The sticker price only means something once the same capabilities sit behind it. So the real question isn't "what does the cheapest tier cost," it's "what does the cheapest tier that actually keeps my agent running reliably cost."

Ask whether storage survives between sessions or resets on every deploy. Ephemeral volumes that wipe context don't count for anything meant for production use. Ask whether uptime monitoring and auto-restart come included at the entry tier, or whether the agent simply stays down until someone happens to notice. Ask whether integrations to Gmail, Slack, GitHub, and similar tools are built in, or whether each one means manual OAuth setup and ongoing maintenance on the user's side.

Check whether the base tier allows bringing your own API keys, so inference costs go straight to the model provider, or whether the platform marks up model access as part of its own margin. Ask who applies framework updates and CVE patches, the platform or the user, and how quickly that happens after a vulnerability gets disclosed.

Look at whether the pricing model is built for one agent or for one agent per customer. Per-minute or per-sandbox billing that scales down to near-zero on idle is what a product needs. A flat monthly slot is what a personal deployment needs, and the two aren't interchangeable.

Check the data handling terms directly: are conversations, files, and terminal sessions used to train models. That answer belongs in the Terms of Service, not just in marketing copy. And check on lock-in: can files be exported and the account canceled on the user's own schedule, or does leaving require platform-specific migration work first.

Building an honest comparison means listing every candidate platform across all of these dimensions, including the monthly price on the homepage. The platform that looks most expensive on paper is often the cheapest once ops time, patching, and integration labor get counted. Entry-level managed hosting earns its price when it includes real persistence, real monitoring, BYOK, and integrations that don't require a weekend of manual setup. Anything short of that falls outside what entry-level should mean. It's a discount on the sticker price and a bill for everything else, due later, once the gaps appear.