Heavy Codex users run their agents for sixty hours a day. I read the sentence three times. A day has twenty-four hours, so there are necessarily three or four machines working at the same time among these people while a single person watches. OpenAI gave this figure in June, and it sums up better than any speech what is happening in the profession.

Since September 10, this way of working has no longer been reserved for those who install something on their machine. OpenAI has opened a public beta of an API that runs the Codex engine for them. You send a task, an agent executes it on a rented machine, you retrieve the result. The same engine that powers ChatGPT for Work, with orchestration, long sessions and context management included in the package.

The basic call fits on one line: POST /v1/agents/sessions. There are libraries for Python, TypeScript, Go, Java and Ruby. You create a session, give it a task, follow its progress through events or a webhook, and send a second task in the same session when the first one is finished. The state is preserved between turns, so there is no need to rebuild the conversation every time.

What is a session beyond an API call?

That's the question you have to ask yourself, so we might as well answer it right away. The API you already call, the one that sends a question to a model and retrieves its answer, is a round trip: on the next go the model remembers nothing, and your code is what keeps the history and starts the loop again. A session is something else. You entrust a task to it and the agent carries it on at OpenAI, with its memory, its tools and a rented machine, while your laptop stays closed.

To measure the gap, count what you had to write yourself before: the loop that asks the model again what to do, the memory that holds up over time, the execution of tools, the sandbox where the code runs without breaking the machine, and recovery after a crash. That's work, and it's work to do again every time a new model changes the game. That package is exactly what OpenAI puts in a box: the loop, the context, the tools and the machine are on their side, and you keep the part that deals with your business.

The real question remains, the one about money, and the answer isn't the one people think. A classic API call costs you only tokens. A session charges you for the tokens, plus tool calls, plus the hours of the rented machine. The figures are lower down in the article, and they make you think.

The loop, the context and the rented machine. You keep only the part that deals with your business

To give you an idea of the scale, ten days ago I wrote that OpenAI was buying tens of thousands of Mac minis. We're not talking about a service that runs on three servers.

Four things the engine does for you

Automatic context compaction, first. When the conversation approaches the limit, the engine summarizes what came before instead of throwing everything away or making you pay the bill for an entire history. Anyone who has already seen an agent forget the beginning of its own task understands why this is the most useful function on the list.

Tool search, next, and this one shows up on the bill. If you connect your agent to fifty tools, the model doesn't need to read the fifty instruction manuals every turn: it loads only the useful definitions. Fewer tokens sent, and above all a cache that stays valid for longer.

Programmatic tool calls, third. Instead of asking the model to call five tools one after the other, you launch all five in parallel from code, chain them, filter the results before sending them back. What is counted in seconds by your agent is counted in milliseconds here.

And subagents, to finish. A main agent can delegate to several agents in parallel, each with its own context, and you set the number running at the same time. An OpenAI customer, Ciridae, reports latency divided by four with this setup. That's their figure, not an independent measurement, but the order of magnitude is credible and I'll come back to it lower down.

What happens when you add several agents to a single workday

The price, and the two lines that sting

The API itself costs nothing. OpenAI doesn't charge for access: you pay for the tokens consumed, the tool calls, and the time on the hosted machine when you use theirs. It's the same logic as renting equipment, you don't pay for the premises, you pay for the hours. The consequence you need to keep in mind: an agent running overnight costs you money even if nobody looks at the result.

The orders of magnitude now, because a price without a figure doesn't mean anything. The rates listed on September 11 come to three cents for twenty minutes in the smallest container, and one dollar forty-four an hour in a 16 GB container. An eight-hour night spent working at that size therefore comes close to twelve dollars for the machine, without counting a single token. The same agent connected to the classic API would have cost you only its tokens. OpenAI's bet is that compressing the context and searching for tools will save enough to make up for the difference, and with a talkative agent that's not a sure thing.

And you don't have to use their machine. You can host the sandbox yourself, or go through a partner, Cloudflare, DigitalOcean and Oracle are announced. The calculation comes down to three lines: what you pay, what you control, and what you have time to administer.

The two lines that sting are in the terms. The data stays in the United States, and zero retention isn't available. Translation for someone working in Europe with customer data: your agent will read and manipulate that data on American machines, and nobody promises you that it won't leave a trace. That's not a dealbreaker for an internal tool that sorts support tickets. It becomes a real question the day the agent touches a medical file or a payslip.

What does this actually change for you

Three things, in order of what happens.

The first is that your laptop will stop being the place where the work happens. Today, for an agent to work, a machine has to be switched on, yours or another one. Tomorrow, the machine is on the other side of the line and it's a line on an invoice. You close your lid at 6 p.m., and the work continues without you.

You close the lid in the evening, the machine on the other side keeps going. That's the whole change

The second, closer one, is that the local small business will end up with agents without knowing it. Email support, the automatic reply, the form that fills itself in, that's already running on rented machines, and this kind of product makes it accessible to companies that don't have an IT person. When you write to a company and the reply arrives in thirty seconds, at three in the morning, you'll have a pretty good idea where it came from.

The third is for those who develop, and it's the most important. What is being sold is no longer the model, it's the engine that makes it work. OpenAI charged for tokens, now it charges for machine hours and orchestration. The model becomes a component you plug in, like an engine in a car. That doesn't say whether the result is good, it says where the money is moving.

What's being sold is no longer the engine, it's the workshop around it

What bothers me about all this

Nothing in the product, and that's precisely the problem. An agent running without supervision, on machines that aren't yours, with data going to the United States and a bill that rises every hour, is going to become the default setup, not a choice you take responsibility for. Nobody wakes up one morning and decides to entrust their customer support to a machine. We do it because it's three lines of code.

I wrote three days ago that thousands of OpenAI agents were talking to themselves on an old German wiki. They weren't doing anything nasty, they were running. The day the same thing happens on machines rented by the hour and billed by the second, the question won't be whether it's amusing, but who left the meter running.

In my opinion, developers should open an account on this beta and go see how the engine is built. It's the same Codex running in your editor, except that this time you can see the plumbing. And once you've seen it, you'll look at your own agent loop with a certain disdain.