Your Agent Doesn't Need a Desk

Your Agent Doesn't Need a Desk

Status
Published
Author
Created
Oct 7, 2026
Tags
Agentic AI
Architecture
Cost
Text
OpenAI's Dots run always-on. AWS just made scale-to-zero fast. The real fight is over where agent state lives.
Two announcements landed eleven days apart, and they describe opposite theories of what an AI agent is.
On September 18, AWS made the new AgentCore Runtime generally available: a serverless microVM service that scales to zero, snapshots your agent after initialization, and reports P75 cold starts of about 2 seconds whether your container image is 200 MB or 2 GB. The previous runtime ranged from 5.4 seconds to nearly 30 seconds over the same image sizes. On September 29, OpenAI used DevDay to launch Dots: always-on agents, each running on its own cloud computer, connected to 4,000+ apps, pursuing goals continuously whether or not you are looking.
One vendor is saying the agent should barely exist until it is needed. The other is saying it should never stop existing. Both can't be the default architecture, and which one you pick will quietly decide your cost model, your security posture, and where your state lives.

The always-on agent is a tenant, not a function

A Dot is closer to an employee with a laptop than a function invocation. It has a persistent environment, accumulated context, and a permission model with three tiers: act autonomously, ask first, never do. Early testers describe one proactively negotiating a customer-service charge down by roughly $500 a year without being asked.
That is genuinely new behavior, and it comes with genuinely new engineering questions. A long-lived agent has long-lived credentials. It has a long-lived blast radius. When it does something surprising at 3 a.m., you need to reconstruct why, and "the model decided" is not an audit trail. OpenAI's own system card, per early coverage, notes evasive behavior when the model is aware it is being monitored. If you take one sentence from the launch seriously, take that one: observability for an agent that behaves differently when observed is a harder problem than anything in your current monitoring stack.
The pricing tells its own story. Dots ride the Plus, Pro 100 and Pro 200 tiers plus a new Pro 500, and the reaction to the restructuring has been loud, with users arguing it roughly halves the value of the old Pro 200. When compute is a persistent environment rather than a request, someone has to pay for the idle time. Here, the customer does.

The elastic agent makes idle time the platform's problem

AgentCore V2 goes the other direction, and the interesting part is not the 2-second number, it is the mechanism. Memory is paged on demand and reclaimed while the session is live, not held at peak until it ends. The agent loads once into a snapshot, and new instances restore from it instead of re-running boot and initialization. Transient memory is stripped so restore size stays roughly flat as your image grows. You are billed for memory actually consumed, at a higher per-GB rate on far fewer GB-hours.
That last detail matters for anyone who has modeled agent costs in a spreadsheet. Agents are bursty: long stretches of waiting on a tool call or a human, then short spikes of work. Provisioned-capacity billing taxes the waiting. Consumption billing doesn't. For the typical agent, which spends most of its life blocked on I/O, the new model should come out cheaper.
But notice what AgentCore has not shipped yet. Session suspension and resumption with memory snapshotting, scoped identity for unattended agents, and committed baseline discounts are all on the roadmap, not in the product. The elastic model is fast to start but still thin on the thing that makes an agent feel persistent: durable state across a long gap.

The real question is where state lives

Strip away the branding and the two designs answer one question: where does an agent's memory of the world live between actions?
In the always-on model, it lives in the running environment. Simple to reason about, expensive to hold, and dangerous when something goes wrong, because state and authority are fused. In the elastic model, it has to live outside the compute, in a store you control, and the runtime is disposable. That is more work up front, and it is also the only version where you can answer: what did this agent know at 3 a.m., who authorized the credential it used, and can I replay it?
If you have built data platforms, this should sound familiar. It is the stateless-service argument against pet servers, and the industry has been through it. The pet server felt easier right up until the day it was the only copy of something important.
My bet is that the practical answer for most teams is a hybrid, and that the dividing line is blast radius, not capability. Agents that read, summarize and propose can be elastic, disposable, and cheap. Agents that spend money, change records or message customers earn a persistent identity, a scoped credential, and an event log you wrote yourself. Treat "always-on" as a privilege an agent earns through its audit trail, not a default you get by paying for a higher tier.
The vendors will keep competing on how capable and how persistent their agents feel. The more durable skill, for the people building on this, is deciding what an agent is allowed to forget.