Agents are a memory problem

An agent that is always available is always occupying memory. That single fact sets the cost floor for the entire workload, and remarkably little else about the agent changes the bill.

The workload changed shape

For twenty years the dominant cloud workload was request and response. A request arrives, work happens, memory is handed back. Idleness is free, which is why scale-to-zero became the defining trick of the last decade of infrastructure: if nothing is happening, you should be paying for nothing.

An agent breaks that pattern, because being there is the job. It holds context. It waits on an event that may not arrive for an hour. It picks up a conversation from last Tuesday and expects to remember it. Availability is not overhead around the product; availability is the product.

Once availability is the product, the resource that governs your economics stops being CPU and starts being memory. CPU is time-shared, so an idle agent consumes very little of it. Memory is not time-shared. An idle agent occupies precisely as much as a busy one, every second, for as long as it exists.

What being there costs

Today a hosted agent costs megabytes at best, and a whole virtual machine at worst. The range depends on how strongly you need one customer's agent kept apart from another's, and stronger separation has always meant a heavier unit.

The revealing part is where that weight sits. It is mostly not the agent. An agent's own working state is small: a long conversation held as structured messages is a fraction of a megabyte, and serious state such as retrieval corpora and caches generally lives on other machines. What costs is the envelope around the agent. The language runtime, the standard library, the operating system underneath, replicated once per separated unit.

You are not paying for the agent. You are paying for the box it arrived in.

That distinction matters because it tells you the cost is structural rather than intrinsic. Nothing about the idea of an agent requires megabytes. The megabytes come from how we package it.

Then multiply

Analysts project more than a billion deployed agents by 2029. Take any per-agent figure and multiply. At dozens of agents per server, a billion of them implies a fleet nobody is going to build. At thousands per server, the same population needs a fraction of the machines.

The obvious escape is to wait for hardware to make the problem go away, and it will not. Memory capacity per pound has improved far more slowly than compute per operation, and it moves with supply cycles rather than following a dependable curve. Logic got the exponential. Memory did not. You cannot schedule your roadmap around a floor that falls on its own.

What the floor decides

A cost floor is not only a number on an invoice. It quietly determines which products are buildable at all.

• An agent for every user. If residency costs megabytes, you cannot give a persistent agent to each user of a consumer product. You give them a shared queue and call it a feature.
• Agents that live longer than a session. If being resident is expensive, you kill the agent between sessions and rebuild its state on return. Every rebuild is latency you apologise for and code you maintain.
• Agents that mostly wait. Monitoring something, holding a position, watching for a condition. Many of the genuinely useful agents are idle almost all of the time, and idle is exactly what the current cost structure punishes hardest.

Collapse the floor and each of those moves from uneconomic to unremarkable. That is the interesting thing about cost floors. They do not merely make existing products cheaper, they decide which products get proposed in the first place.

The number worth moving

Whoever collapses the memory cost per agent sets the cost floor for the entire workload, and the floor is what the market gets built on top of. It is a better place to compete than almost anything downstream of it.

That is the number MoatCell is built to move. A hosted agent costs kilobytes rather than megabytes, so one server carries thousands where it used to carry dozens. How it works stays quiet for now.

MoatCell is pre-launch. Density figures are benchmarked against competing platforms rather than projected. If agent hosting economics are your problem, join the early-access list.