Attention Is the Scarce Resource

WIRED reports that OpenAI is testing a version of Codex that continues working until it is put to sleep. Code reviewed by WIRED shows an agent that creates its own follow-up tasks, continues them across sessions, uses past interactions and knowledge of the user to choose what to work on next, and occasionally messages the user first. OpenAI confirmed the test and has no immediate launch planned.

The detail that matters most is where the setting lives. Persistent mode appears in Codex’s reasoning-effort menu, among the levels that decide how much computing power, how many tokens, and how much time a model may spend before it answers. It is the most demanding position on that dial. The settings below it stop after minutes or hours whether the work is finished or not. This one does not stop.

Persistence, in that design, is delivered as more inference.

The demand behind it is real. Software work should continue after a developer closes the browser or leaves for the night. The open question is what the customer is paying for when it does.

What the customer is paying for

Agentic systems return results on an unpredictable schedule and report success and failure in the same composed voice. Someone has to stay present to check what arrived, restore the context, judge whether it is right, and decide what happens next. That is the real bill. Inference is cheap and getting cheaper every year, and the person watching it is the constraint. A system that generates quickly while its operator absorbs a continuous attention burden has added a productivity tool rather than capacity.

More inference can enlarge that burden rather than reduce it. An agent that runs through the night and creates its own follow-up work produces more output to review, arriving on a less predictable schedule, from a chain of decisions nobody was present for. WIRED reports that Persistent mode selects that follow-up work using the agent’s past interactions and knowledge of the user, so an early misreading can shape the hours of work that follow from it.

The constraint on agentic software work is the attention it takes to keep it moving.

What a remote worker returns

Tapestry is a remote worker. The customer provides the mission, Tapestry executes it without supervision, and evidence guides the work.

For the first persona, the Python Developer, that has a plain shape. Executives, project managers, architects, and other higher-level roles provide requirements, objectives, constraints, and priorities. Tapestry does the engineering and hands back a reviewable result.

The Python Developer takes requirements and requests and returns pull requests for review.

A person reviews the result rather than the process. That is the whole of the interface, and it is what the attention argument turns on: an artifact arriving at a known boundary costs a fraction of what continuous presence costs.

Five core elements carry the work as one system.

• The Knowledge Engine grounds claims, evidence, and proofs, and stays authoritative for what is currently known.
• The Actor performs the work, produces evidence, and submits proposed releases.
• The Motivator organizes eligible work over durable task records, maintains scheduling invariants, and dispatches approved work.
• Engram provides persistent, relatively static recall, proposing a previously accepted conclusion that remains subject to current Knowledge Engine evidence.
• The Regulator judges what may enter the system and what may leave it.

Spyder is the code-building component deployed with the Python Developer instance. The Motivator drives Spyder from work the Actor populated, and the Actor is the backstop for the CPU-bound generation path. Code construction is one function inside the system.

Persistence and consistency

Language model output is improving quickly. It also remains variable. The same model can produce an excellent implementation in one run and a subtly flawed one in the next, understand the central requirement while missing a constraint, or solve a hard problem and then make a basic mistake in the code around it.

More time and more tokens buy more opportunity to reason. They also buy more opportunity to introduce assumptions, follow unproductive branches, and drift from the original requirement. An early misunderstanding can become the premise for hours of technically competent work aimed at the wrong target.

Progress is measured in accepted work, not in elapsed time or tokens spent.

Tapestry keeps the work state outside any one inference. Requirements stay authoritative. Tasks retain their priorities, dependencies, attempts, and evidence. When a task fails, the evidence is recorded, the work is revised, the next implementation is generated, the relevant tests are rerun, and whatever becomes ready advances.

One model invocation does not have to carry the requirement, the work state, the implementation, the tests, and the release decision as an expanding internal narrative.

The inference can end while the work remains.

What each design makes durable

Beyond the dial

Persistent mode answers a real demand, and it is the answer the surrounding architecture supports. When one agent holds the requirement, the plan, the implementation, and the judgment, continuity means keeping that agent running, and turning the dial up is the available move.

Tapestry starts from the same demand and puts the durable parts outside the model. The mission, the task records, the evidence, the artifacts, and the release decision survive any particular inference, which is why the work can continue with nobody watching it continue.

Improving models increase what Tapestry can accomplish. They do not have to hold the whole engagement in context for it to hold together.

If you are evaluating an agent this year, measure it by the attention it takes from you. That is the number you pay every week.