The Future of Work Is Runtime

The next company will not just describe how work gets done. It will compile the work into a system that can run.

Most companies do not have workflows.

They have stories about workflows.

The real process lives across documents, software, meetings, inboxes, habits, and the heads of experienced employees. The official procedure says one thing. The work itself moves through a web of judgment calls, hidden prerequisites, remembered exceptions, and manual handoffs.

That arrangement was good enough when humans were the only intelligence available to the firm. A person could read a policy, infer what it meant, ask a colleague what was missing, remember where the work stopped, and carry the process forward.

AI exposes how fragile that system always was.

Give an agent a long document and tell it to follow the rules, and it may perform brilliantly. It may also skip a check, lose its place, take an action too early, or confidently continue after the task should have stopped. The failure looks like a model problem. Often it is an operating-model problem.

The company gave the machine prose when the machine needed a program.

That is the next shift in the future of work. We are moving beyond AI as a tool employees use and toward AI as a labor layer the company must govern. To make that layer useful, work has to become more explicit, more modular, more testable, and more executable.

The future of work has a runtime.

The future of work is runtime.

From Workflow to Work Program

In AI Leverage Is an Operating Model Problem, I argued that the unit of change is not the prompt. It’s the workflow.

Every company now has access to capable models. Access is no longer the scarce thing. The scarce thing is knowing where intelligence belongs, how the work should change, what judgment must remain human, and what platform needs to exist underneath the process so the gains compound.

Then, in Productive Time Dilation, I pushed the argument further. Intelligence is becoming infrastructure. Labor is becoming programmable. The people who own systems that turn machine intelligence into repeated economic output will capture more of the surplus than people who merely use AI inside someone else’s system.

The system is the wealth.

A new paper makes the mechanism behind those claims much more concrete. In Compile, Then Page: Executable SOP Programs and a Capability-Gated Runtime for Procedural LLM Agents, Chenglin Yu and his coauthors study what happens when standard operating procedures stop being treated as text and start being treated as programs.

The researchers begin with a familiar enterprise problem. Banks, clinics, service desks, and other high-consequence operations depend on long procedures with conditional paths. Verify this before doing that. Ask for missing information. Refuse the request if a required condition fails. Use one tool if the user is authenticated and another if they are not.

The normal approach is to place the whole procedure in the model’s context and hope it follows the instructions.

The paper tests a different approach. A deterministic compiler turns the procedure into pseudocode. Each user goal becomes a process function. Each rule becomes a subroutine with a specific verification method. Each decision returns not only a verdict, but the evidence supporting it.

The agent does not simply receive a policy.

It enters a work program.

That distinction is larger than it sounds. A policy tells the worker what should be true. A program specifies what to check, in what order, which conditions open or close a path, what evidence must exist, where the process should resume, and when the system must stop.

This is not prompt engineering.

It is workflow architecture.

Prose Was Built for Human Labor

The modern company runs on text because text is flexible.

Job descriptions, playbooks, policies, handbooks, process maps, strategy documents, and meeting notes all assume a human reader. They leave room for inference because people are good at filling gaps. The experienced operator knows which rule matters, which database is reliable, which exception is real, and which step can safely be skipped.

That flexibility carries a hidden cost. The organization becomes dependent on interpretation.

Two employees can read the same procedure and execute it differently. A new employee needs months of repetition before the document becomes practical judgment. When an expert leaves, part of the operating system leaves with them. Managers compensate through training, supervision, meetings, and institutional memory.

AI does not remove the cost of ambiguity. It scales it.

A machine can read every policy in the company and still fail at the exact moment the policy must become action. The model has to translate language into state: where am I, what has already happened, what remains unresolved, which tool should I use, what did the result prove, and what am I allowed to do next?

That translation is the work.

The paper’s compiler makes the hidden structure explicit. It preserves sequence. It distinguishes an ordinary choice from a gate that should stop at the first valid path. It moves authentication checks in front of actions that require authentication. It binds every conclusion to evidence. It breaks large procedures into smaller functions that can be called and completed.

This is what companies will have to do with their own operations.

Not every sentence needs to become code. Not every human judgment should be reduced to a Boolean rule. But any process assigned to machine labor needs enough structure to run, enough context to act, enough state to continue, and enough evidence to be reviewed.

The SOP becomes software.

The Active Frame Is the New Unit of Management

Compiling the procedure is only the first half of the paper’s idea.

A complete program can still be too large and distracting. If the agent sees every instruction at every moment, the current step competes with the rest of the process, the conversation, the tool history, and the user’s latest request.

The researchers solve this with a stack-based runtime. The runtime keeps track of the call stack, the current position, the variables, and the results returned by prior checks. It then “pages” only the active frame into the model’s immediate context.

In plain language: show the model the part of the job it needs now, preserve everything else outside its attention, and restore the right state when the current subtask is complete.

You don’t think about every single part of your job while working, do you? Why should the AI?

The model remains the semantic executor. It speaks with the user, chooses tool arguments, reads evidence, and makes local judgments. But it no longer has to hold the entire procedure and its current location inside a rolling conversation.

The system remembers where the work is.

This matters because attention is part of the production function. Giving a model more information is not the same as giving it the right information at the right time. A large context window is storage. It is not management.

Humans already understand this intuitively. A great manager does not walk into every meeting and recite the entire corporate strategy, employee handbook, customer history, and project plan. The manager brings the relevant objective forward, clarifies the current decision, preserves the broader context, and keeps the work moving.

Agents need the same discipline, but encoded in the system.

The active frame becomes a new unit of management. It is the bounded piece of work the agent is authorized and equipped to perform now. It contains the immediate objective, the required inputs, the available tools, the relevant constraints, the expected evidence, and the definition of done.

This changes how we should think about jobs.

A job is a bundle of responsibilities wrapped around one human. A work program is a graph of objectives, checks, decisions, actions, and exceptions that can move across humans and machines.

The job was the old container.

The active frame is the new one.

Management Becomes Architecture

The first industrial managers allocated bodies, machines, and time.

The next generation of managers will allocate human and machine cognition across a live graph of work.

That means management decisions will increasingly be expressed as architecture. Which system gets the task? What context can it see? What tools can it use? What action requires approval? What evidence must come back? What happens when a check fails? Which model is capable enough for the procedure? Where does the work pause? Who owns the exception?

These questions used to live in training and supervision. Now they also live in permissions, schemas, workflow definitions, evaluation suites, and runtime controls.

The org chart will not disappear. It will be joined by the workflow graph.

The workflow graph will show how intent becomes action. It will include human employees, agents, databases, APIs, approval gates, memory, policies, and review queues. Some nodes will generate. Some will verify. Some will decide. Some will act. The highest-risk nodes will remain hard-gated by software or a human.

This is where the future-of-work debate usually becomes too shallow. We ask whether a model will replace an accountant, lawyer, analyst, salesperson, or software engineer. But jobs are not atomic. They are political and administrative packages assembled around the old cost of coordination.

AI will not simply replace those packages one at a time.

It will unbundle them.

Research may move to one system. Drafting to another. Reconciliation to a third. A human may handle the exception, the client conversation, and the final judgment.

The work will be recomposed around capability, risk, cost, and trust.

Some jobs will shrink. Some will become more powerful. New roles will appear around AI taste testing, workflow design, context engineering, evaluation, model operations, agent supervision, data quality, and exception handling. The important divide will not be between people who use AI and people who do not.

It will be between people who remain trapped inside tasks and people who can design the systems that perform them.

Capability-Gated Autonomy

The paper includes an important warning for anyone who believes more agent scaffolding is always better.

Recent evidence says it isn’t.

On one bank-task evaluation, converting the official procedure from prose into a compiled representation raised one model’s pass rate from 70.4% to 86.4%. Adding the runtime raised it again to 92.8%, with perfect refusal accuracy on the screened refusal set. Across seven domains, two stronger models benefited from the program-guided runtime.

Weaker models were harmed.

For two of them, the runtime reduced performance by 14 to 26 points on the bank tasks. The problem was not that they could never reconstruct the state. When directly tested, they could. The problem was spontaneous discipline during execution. One model under-attended to the active frame. Another kept verifying after the goal had already been achieved.

The system exposed a capability boundary.

This is a critical lesson for the future of work. Autonomy is not a product setting. It is an earned property of a specific system performing a specific class of work under specific controls.

The right question is not, “Are agents ready?”

Ready for what? With which model? Inside which workflow? Using which data? With what tools? Under which permissions? Evaluated against what standard? At what cost of failure?

The paper’s deployment rule is simple: compile first, then page only after a model-level discipline check. Even then, the runtime provides soft enforcement. It makes deviations visible, but it does not prevent every bad action. Irreversible actions still need hard controls at the tool layer.

That is how serious companies should approach autonomy.

Drafting can be broad. Recommendations can be bounded. Reversible execution can expand with evidence. High-consequence actions should remain permissioned, observable, and interruptible.

Autonomy should rise with demonstrated reliability.

Judgment Becomes Even More Valuable

When execution becomes cheap, judgment becomes expensive.

The model can generate the report, inspect the records, prepare the options, and run the checks. But someone still has to decide what goal matters, what tradeoff is acceptable, what evidence is sufficient, and what should enter reality.

This moves human value up the stack, it doesn’t erase it entirely as AI alarmists claim.

The most valuable employees will know how to define objectives, decompose work, supply context, set constraints, inspect evidence, resolve ambiguity, and recognize when a plausible output is wrong. They will understand the domain well enough to supervise machine labor and the system well enough to improve the workflow.

Taste matters because output becomes abundant.

Trust matters because execution becomes autonomous.

Agency matters because someone has to decide what the machine should do.

This does not mean every employee becomes a philosopher-manager floating above the work. Domain expertise still comes from contact with reality. A lawyer cannot supervise legal work they do not understand. An operator cannot verify a process they have never run. A manager who only reads agent summaries will slowly lose the ability to detect when the system is drifting.

The apprenticeship problem is real.

Junior employees historically built judgment through repetition. They drafted the memo, checked the numbers, updated the CRM, prepared the analysis, made mistakes, and watched experienced people correct them. If agents absorb the entry-level work, companies must create a new path for humans to develop the judgment required to supervise it.

The best organizations will not remove people from the work entirely. They will design deliberate learning loops: simulation, shadow execution, sampled review, failure analysis, rotation through exceptions, and direct exposure to customers and consequences.

You cannot govern what you no longer understand.

The Economics of Executable Work

Once work can be compiled, routed, run, checked, and improved, the economics of the firm change.

Headcount becomes a poor proxy for capacity. A small team with strong workflows can operate more surface area than a large company built on meetings and manual coordination. The minimum viable organization shrinks while the maximum viable ambition of an individual expands.

But the deeper change is that the workflow becomes an asset.

The first time a task runs, the system produces an output. The tenth time, the team has a repeatable process. The hundredth time, it has execution history, edge cases, evaluations, trusted data paths, permission boundaries, cost curves, and a growing map of what works.

That operational knowledge compounds.

The prompt does not.

This is why ownership matters. If you own the workflow, the customer relationship, the proprietary context, the feedback, and the asset produced by the process, machine labor can create durable leverage. If you merely perform tasks inside someone else’s runtime, you may become more productive without capturing the surplus.

The industrial economy rewarded owners of factories. The software economy rewarded owners of applications and networks. The agentic economy will reward owners of executable operating systems.

That can mean a company’s internal platform. It can mean a vertical AI business built around trusted execution. It can mean a single high-agency operator who has encoded enough context and workflow to function like a small institution.

Compile the Company

Most companies are not ready to turn every process into an agent workflow. That’s fine. The work begins with a single valuable loop.

Find a process that repeats, consumes meaningful human time, has a clear economic outcome, and can be observed. Map what actually happens, not what the official document claims happens. Identify the inputs, the decisions, the tools, the hidden prerequisites, the failure states, the exceptions, and the definition of done.

Then make the work executable.

Turn vague policies into explicit conditions. Tie each condition to a way of checking it. Separate reversible actions from irreversible ones. Move state out of the conversation and into a system that can preserve it. Bring the current objective forward. Require evidence. Record the trace. Test the workflow against cases that should succeed and cases that should refuse.

Do not start with maximum autonomy.

Start with visibility.

Let the agent prepare the work while a human approves it. Measure where it succeeds, where it stalls, where it invents, and where the procedure itself is ambiguous. Turn failures into evaluations. Turn corrections into context. Turn repeated decisions into rules.

Expand autonomy only when the evidence supports it.

Just like with human employees.

The paper also reveals a tradeoff that executives should not ignore. Its paging method improved accuracy and traceability, but it used more model calls and more total prompt tokens. Better systems do not always look cheaper at the level of one task. The return comes from fewer errors, safer refusal, clearer audits, faster scaling, and the ability to move more work through the organization without equivalent coordination cost.

Optimize the business system, not the token bill.

In fact, tokens are a poor way to measure inputs or outputs.

The company that does this well will become easier to run because it becomes easier to see. Work will have state. Decisions will have evidence. Policies will have executable structure. Exceptions will have owners. Every important workflow will produce both an outcome and a trace.

That is not just automation inside a black box.

It is a more legible firm.

The Future Belongs to the Architects

The future of work will not be defined by a single model, a universal digital employee, or one dramatic moment when every job changes.

It will arrive workflow by workflow.

A policy becomes a program. A program gains tools. The tools gain permissions. The work gains memory. The system gains evaluations. The agent earns more autonomy. The human moves from direct execution toward direction, review, exception handling, and ownership.

Over time, the company stops treating intelligence as something employees occasionally access and starts treating it as infrastructure that work runs on.

That’s the shift we are seeing happening.

The old company described how work should happen and relied on people to reconstruct the process.

The new company will encode how work happens, preserve its state, expose the right instruction at the right moment, and learn from every execution.

The job description was a document.

The future of work is a runtime.

Imagine the businesses people are going to build with this?

Friends: in addition to the 17% discount for becoming annual paid members, we are excited to announce an additional 10% discount when paying with Bitcoin. Reach out to me, these discounts stack on top of each other!

Thank you for helping us accelerate Life in the Singularity by sharing.

I started Life in the Singularity in May 2023 to track all the accelerating changes in AI/ML, robotics, quantum computing and the rest of the technologies accelerating humanity forward into the future. I’m an investor in over a dozen technology companies and I needed a canvas to unfold and examine all the acceleration and breakthroughs across science and technology.

Our brilliant audience includes engineers and executives, incredible technologists, tons of investors, Fortune-500 board members and thousands of people who want to use technology to maximize the utility in their lives.

To help us continue our growth, would you please engage with this post and share us far and wide?! 🙏