It is not.

A model can propose, calculate, summarize, criticize, and sometimes surprise us. It can read more material than any individual. It can generate hundreds of hypotheses before lunch. It can write code, design experiments, compare results, and explain its reasoning in language that sounds remarkably authoritative.

But it cannot become a credible research institution merely by producing more impressive answers.

A lab requires mandates. Tools. Memory. Budgets. Permissions. Evidence. Adversarial review. Independent verification. Claim boundaries. Human authority.

The model is one worker inside that system.

The AI research lab is the thing we are building.

The Chatbot Frame Is Too Small

The chatbot was a useful way to introduce AI

A person types a question. A model returns an answer. The interface is simple, the feedback is immediate, and the value is easy to understand.

That interaction trained us to judge AI at the level of the response.

Was the answer accurate? Was it useful? Did it sound intelligent? Did it save time? Could a better prompt produce a better result?

Those were the right questions for the first phase.

They are too small for the next one.

Research is not a single response. It is a chain of work performed over time. A serious research effort may include source acquisition, data cleaning, hypothesis generation, experiment design, implementation, testing, falsification, replication, interpretation, review, and publication.

Each step can fail in a different way.

The wrong source can enter the system. A dataset can contain leakage. An experiment can test something other than the stated hypothesis. A result can be statistically real but economically meaningless. A valid observation can be summarized badly. A narrow finding can become an expansive claim. An impressive output can inherit authority it never earned.

No individual answer can manage all of that.

Once AI begins performing research work rather than merely discussing research questions, the unit of design changes.

The answer is no longer the product.

The workstream is the product.

Intelligence Is Not Reliability

The distinction at the center of this project is simple:

Intelligence and epistemic reliability are different engineering problems.

Intelligence helps a system generate, transform, and interpret information. It enables the model to identify patterns, propose explanations, write code, reason through alternatives, and navigate unfamiliar domains.

Epistemic reliability is the system’s ability to determine what deserves belief.

Those capabilities overlap, but they are not the same.

A highly intelligent model can still rely on the wrong source. It can make an invalid inference. It can accept a convenient explanation without testing alternatives. It can produce a persuasive summary that hides uncertainty. It can follow a flawed method with extraordinary competence.

Better reasoning does not automatically create better provenance.

More context does not automatically create independent verification.

Greater fluency does not automatically create calibrated claims.

The most capable model in the world still needs to know which files are authoritative, which actions are permitted, which results have been independently reproduced, which objections remain open, and where its mandate ends.

These are not model-weight problems.

They are institutional-design problems.

The Institutional Formula

The research system we are building can be described with a compact formula:

Research system = models + mandates + tools + evidence + memory + critics + gates + authority

Every term matters.

Remove the models and little work gets done.

Remove the mandates and the work loses direction.

Remove the tools and the system cannot act on the world.

Remove the evidence and it has only assertions.

Remove the memory and it cannot compound.

Remove the critics and errors survive unchallenged.

Remove the gates and weak results become stronger claims.

Remove authority boundaries and the system begins deciding things it has no right to decide.

The model is important.

It is simply not the whole machine.

Models Are Workers

We should think of models as cognitive workers.

Some are fast and broad. Some are slow and careful. Some are good at code. Some are better at reviewing arguments, finding inconsistencies, searching literature, translating formal notation, or generating alternatives.

The choice of model matters in the same way that the choice of worker matters. Capability, specialization, cost, speed, and judgment all affect the result.

But no serious institution would define itself by the intelligence of one employee.

A brilliant researcher operating without source controls, budgets, peer review, or research ethics does not become a lab. A room full of brilliant researchers without coordination does not become one either.

Models need roles. They need work orders. They need access to the right materials and restrictions against the wrong actions. They need to produce outputs that can be inspected by people and machines that were not involved in creating them.

A model should not be asked to be the worker, manager, critic, auditor, and executive at the same time.

That may create the appearance of completeness.

It does not create independence.

Mandates Turn Questions Into Work

A question asks for an answer.

A mandate defines a body of work.

That distinction becomes essential when AI systems operate with tools, files, compute, memory, and time. “Investigate this problem” is not enough.

What exactly is the research question? Which sources may be used? Which inputs are frozen? What counts as relevant evidence? What actions are permitted? How much compute and money may be spent? Which metrics will be evaluated? What conditions require the run to stop?

A good mandate also defines what the system is not authorized to do.

It may permit reproduction but forbid discovery. It may permit candidate generation but forbid promotion. It may permit local testing but forbid external publication. It may allow an evaluator to produce a report while preventing it from rewriting the underlying evidence.

The prompt is becoming the work order.

The quality of the work order determines whether machine intelligence becomes leverage or noise.

Tools Create Consequences

A chatbot produces text.

A research agent can execute code, query a database, transform a dataset, inspect a repository, call a scientific library, run a simulation, or coordinate additional workers.

That is far more useful.

It is also far more consequential.

Once a model can act, permissions become part of the research architecture. The system needs to know which tools are available, which data may be read, which files may be changed, which operations require approval, and which boundaries are absolute.

Tool access should follow the mandate.

A worker reproducing a frozen result may need read access to source files and permission to create a temporary output. It does not need the ability to rewrite the frozen inputs. An evaluator may need to inspect a candidate package. It does not need permission to promote that candidate or alter the evidence ledger.

Capability should not imply authority.

The fact that a system can take an action does not mean it should be allowed to take it.

Evidence Must Be More Durable Than Prose

Models are exceptionally good at producing explanations.

That creates a temptation to treat the explanation as the evidence.

It is not.

A research summary may describe what happened, but it cannot substitute for the underlying files, hashes, commands, measurements, controls, and receipts. A polished conclusion can conceal a missing input just as easily as it can explain a valid result.

The evidence layer must be more durable than the prose layer.

For every consequential result, we should be able to ask:

What were the exact inputs? Where did they come from? Were they altered? Which tool versions were used? What operations ran? What failed? What was excluded? Which controls passed? How much did the run cost? Can another system reproduce the result from the receipt?

These questions are not bureaucracy.

They are the difference between a claim and an auditable claim.

This becomes more important as machine-generated work increases. A human researcher may produce a handful of significant artifacts during a project. A machine research system may produce thousands.

Without structured evidence, the volume becomes unmanageable. The institution starts trusting summaries because reconstructing the work is too expensive.

That is how output abundance becomes epistemic debt.

Memory Must Become a Ledger

Most AI memory is designed to improve continuity.

It remembers preferences, prior conversations, project context, and earlier decisions so the user does not have to repeat them.

Research needs something stronger.

A lab must remember not only what it believes, but why it believes it.

It must remember which sources were authoritative, which hypotheses failed, which controls were missing, which objections remained unresolved, which candidate was held, and which decision changed the direction of the work.

That memory cannot depend on a model retelling the past.

It needs a ledger.

The ledger should preserve artifacts, provenance, decisions, costs, failures, and authority. It should allow future workers to inherit verified state without inheriting unsupported conclusions.

This changes the economics of failed research.

A failed experiment no longer disappears into a folder or a researcher’s memory. Its design, result, and failure mode become reusable institutional knowledge. A later worker can avoid repeating the same mistake or test whether changed conditions alter the outcome.

The institution compounds.

Not because the model remembers more tokens, but because the system retains better evidence.

Critics Must Be Designed to Disagree

Adding another model does not create independent review.

Two agents can share the same context, the same framing, the same training biases, and the same unexamined assumptions. They may agree because the evidence is strong. They may also agree because they were constructed to see the problem in the same way.

Agreement is not independence.

Criticism must be designed into the process.

One worker should test source integrity. Another should attack reproducibility. Another should search for leakage and hidden dependencies. Another should challenge the relationship between the evidence and the claim. Another should deliberately construct alternative explanations.

These critics need explicit adversarial mandates. Their job is not to make the original work sound better. Their job is to find a reason it should fail.

In some cases, they should be isolated from one another’s conclusions until their reviews are complete. Different model families or providers may be useful when procedural independence matters. Their outputs should be frozen before a final evaluator compares them.

The objective is not performative disagreement.

It is error detection.

A credible system does not ask: “Do several agents like this result?”

It asks: “Did sufficiently independent attempts to break this result fail?”

Gates Convert Evidence Into Authority

Evidence and authority are different things.

A result can be real without authorizing publication. A candidate can be interesting without authorizing more spend. A research package can pass technical checks without justifying a claim of human verification.

This is why the system needs gates.

A gate asks a specific decision question and accepts only the evidence relevant to that question.

The Research Evidence Gate asks whether the evidence supports the stated research conclusion.

The Credibility Gate asks whether a specific external credibility claim is justified.

The Publication Gate asks whether a release is operationally and ethically ready to publish.

The Planning Gate asks whether the next bounded discovery campaign should be authorized.

These gates must remain separate.

A missing hosting configuration should not invalidate a local reproduction. A screen-reader review should govern an accessibility claim, not whether private research can continue. A technical result should not silently inherit permission to publish itself.

Coupled gates create two opposite failures.

They allow unrelated requirements to block legitimate work.

And they allow evidence from one domain to grant authority in another.

Good gate design prevents both.

Authority Must Remain Explicit

Autonomous systems create pressure to make continuation automatic.

If a candidate passes, run the next experiment. If the experiment succeeds, expand the search. If the search produces a strong result, prepare the publication. If the publication package is complete, release it.

This feels efficient.

It is also how local success becomes uncontrolled authority.

Every transition changes the risk.

Reproduction becomes discovery. Discovery becomes validation. Validation becomes publication. Publication becomes reputation. In commercial or financial settings, a research result might eventually become a real-world action.

Those transitions should not occur because a model inferred that continuation was probably intended.

Authority must be explicit.

The system should know who can approve additional spend, broaden a mandate, make an external claim, publish a result, or stop the program entirely. It should record that decision and make the resulting permissions visible to every downstream worker.

A gate without an authority model is only a checklist.

An authority model without a gate is only hierarchy.

A credible institution needs both.

Humans Do Not Leave the System

The point of an AI-native lab is not to remove humans from research.

It is to move human effort to the places where it has the greatest leverage.

Machines can search, calculate, transform, compare, reproduce, and criticize at extraordinary scale. They can run many more bounded attempts than a human team could afford.

Humans still choose what matters.

We define the problem. We decide which risks are acceptable. We judge whether a technically valid result is meaningful. We decide when procedural independence is enough and when genuine human expertise is required. We choose what the institution will claim in public.

This is not a sentimental boundary.

It is an architectural one.

Judgment, taste, responsibility, and legitimate authority do not become unnecessary because cognitive work becomes cheaper. They become more important because the volume of possible action expands.

The human role shifts from performing every unit of work to designing and governing the institution that performs it.

That is a higher-leverage role.

It is also a more demanding one.

Why a Swarm Is Not a Lab

The easiest version of agentic research is a swarm.

Give many agents a problem. Let them explore in parallel. Ask other agents to rank the answers. Aggregate the results.

This may produce useful work. It may even produce breakthroughs.

But scale alone does not create institutional reliability.

A thousand agents operating without frozen mandates, provenance, budgets, controls, critics, or gates are simply a thousand opportunities to create convincing error.

The differentiator will not be the number of models deployed.

It will be the quality of the conversion process.

How efficiently can the system turn machine effort into validated observations? How much does each experiment reduce uncertainty? How often do results reproduce? How quickly are false positives killed? How much operator time is required? Can another evaluator reconstruct what happened without trusting the original workers?

The next generation of research systems will compete on research yield, not artifact volume.

More intelligence creates more possibilities. Better institutions determine which possibilities survive.

The Lab We Are Building

CORTEX is our attempt to build this machinery.

It is an AI-native research operating system made of workers, managers, critics, gates, evidence contracts, budgets, permissions, and durable memory. It is designed to run bounded research campaigns without confusing machine activity with established knowledge.

The Frontier Problems Lab is the institution we are building around it.

The destination is a lab designed to attack problems that resist ordinary research workflows. Its advantage will not come from pretending that a model is an autonomous scientist. It will come from coordinating many forms of machine intelligence inside a system built to preserve evidence, invite attack, control claims, and retain human authority.

Our first calibration run was intentionally narrow.

CORTEX reproduced 56 frozen records and the corresponding table exactly. The source hashes matched. The deterministic evaluator agreed. The system then refused to claim that the underlying geometry had been proven.

That refusal was not a disappointing ending.

It was evidence that the surrounding institution had begun to work.

The model completed the assignment. The lab controlled the meaning.

Build the Institution

AI will become more intelligent.

The models will reason better, use tools more effectively, retain larger contexts, and coordinate more complex work. Tasks that currently require elaborate orchestration will become routine model capabilities.

We should welcome that progress.

But more intelligence will not eliminate the need for institutional architecture.

It will increase it.

The faster the workers become, the more important the work orders become. The more candidates the system can generate, the more important falsification becomes. The more persuasive the outputs become, the more important evidence and claim boundaries become. The more actions the system can take, the more important explicit authority becomes.

The future of AI research will not be built by choosing between human scientists and machine scientists.

It will be built by designing institutions where machines can perform enormous amounts of cognitive work without being allowed to manufacture certainty, erase provenance, or grant themselves authority.

That institution will have models.

But it will also have mandates, tools, evidence, memory, critics, gates, and accountable human judgment.

The model is not the research system.

The model is a worker.

We need to build the lab.

That’s what I’m working on!

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

The human brain runs on roughly the power of a dim light bulb.

Inside that twenty-watt envelope, it sees, remembers, predicts, learns, moves a body, reads a room, and maintains a model of itself. It does this continuously. No liquid cooling. No data center. No rack of accelerators drawing enough electricity to power a neighborhood.

That fact has become a kind of talisman in debates about artificial intelligence.

The brain is presented as evidence that biology possesses some vast computational advantage that silicon cannot approach.

Artificial systems may be impressive, the argument goes, but they remain crude imitations of a machine refined by hundreds of millions of years of evolution.

The gap is real.

And we are about to blitz beyond it.

The brain is not millions of times beyond our best AI hardware on every dimension. On raw low-precision computation per watt, the difference may already be less than an order of magnitude depending on how we define the operations. The larger advantage is in memory: how much adaptive state the brain keeps close to computation, how quickly it can use that state, and how little energy it spends moving information.

That is an engineering advantage, not magic. And engineering advantages can be erased.

My bet is that AI hardware will cross the brain’s compute-efficiency envelope within three years. That is a BIG bet.

Within five years, new architectures built around wafer-scale systems, stacked memory, and near-memory computation will close the much harder gap in memory access.

By then, silicon will surpass the individual human brain across most forms of economically useful cognition.

That will not make the human mind irrelevant. It will change where the mind ends.

We Are Counting the Wrong Things

Most brain-versus-model comparisons begin with two large numbers.

Direct cell-counting research places the human brain at about 86 billion neurons. Frontier language models contain hundreds of billions or even trillions of parameters. Put those figures beside each other and the model can appear larger than the brain.

But a parameter is not the artificial equivalent of a neuron.

A better analogy compares parameters to synapses.

A parameter is a stored value that affects how a signal moves through an artificial network. A synapse is a connection whose strength affects how activity moves through a biological network. Both hold persistent adaptive state. Both encode something learned from prior experience.

The neuron is closer to a computational node. It receives signals, accumulates them, transforms them, and produces new activity. In a language model, the closest comparison is not one permanent object but the machinery that produces activations and intermediate results as information passes through the network.

The mapping looks roughly like this:

- Synaptic strength maps to model weights

- Neural activity maps to activations and hidden state

- Neurons and dendrites map to the structures that accumulate and transform signals

- Axons and synaptic events map to communication across memory and compute

Once we compare the right categories, the brain regains its lead.

The number of synapses in a human brain is not known precisely, but common estimates range from around 100 trillion to several hundred trillion, with some estimates reaching a quadrillion.

Publicly documented language models have reached the trillion-parameter range. Kimi K2 for example, has one trillion total parameters, although its MoE design activates only 32 billion for each token.

That distinction matters. Total parameters measure stored state. Active parameters help determine the work performed during one pass.

A sparse model contains a large amount of knowledge without consulting all of it at once.

The brain does something similar. It does not activate every neuron or synapse every time you form a thought. Biological computation is sparse, conditional, and shaped by context. Most of the system remains quiet while small coalitions of activity do the immediate work.

If we compare roughly one trillion model parameters with 100 trillion to one quadrillion synapses, the brain is perhaps two or three orders of magnitude larger in persistent adaptive state.

That is a big gap. It is also a surprisingly bridgeable one.

Two orders of magnitude is not an unknowable biological moat. It’s a technology roadmap.

The comparison still has limits. A biological synapse changes over time, interacts with chemical systems, and can hold several forms of state. Neurons are more complex than the simple units in most artificial networks.

The brain learns continuously while acting through a body. Most language models separate expensive training from mostly static inference.

Parameter count is not intelligence.

Capacity is not capability. A larger system can still be worse.

But the comparison does one useful job: it turns a mystical gap into a measurable one.

The Brain Is a Bandwidth Machine

The easiest way to misunderstand modern chips is to focus only on arithmetic.

Silicon is extraordinarily good at multiplication. Current AI accelerators can perform quadrillions of low-precision operations per second. The harder problem is keeping those arithmetic units supplied with data.

Every model weight has to live somewhere. During inference, weights must be read so they can be combined with activations. When the model is larger than the memory close to the processor, those values must travel across packages, boards, and sometimes networks. Each trip costs time and energy.

Multiplication is cheap.

Moving the numbers is expensive.

This has been understood in chip design for years. Mark Horowitz’s widely cited analysis showed that retrieving data from off-chip DRAM could cost orders of magnitude more energy than performing a basic arithmetic operation.

The hierarchy remains: local movement is cheap, distant movement is expensive. Distance becomes energy.

The brain solves this problem through radical locality.

Its memory is distributed throughout the system. The state that shapes a computation lives at the synapses where signals arrive. Neurons accumulate activity from nearby connections. Communication is sparse, slow, noisy, and massively parallel. Instead of moving a giant weight matrix back and forth between separate banks of memory and compute, biology places the memory inside the network.

The brain does not retrieve its model before it thinks.

The model is the physical structure doing the thinking.

That difference explains why comparisons based only on FLOPS can be so misleading. If we assume the brain performs the equivalent of roughly one quadrillion operations per second while consuming twenty watts, it delivers about 50 trillion operations per second per watt. An NVIDIA B300, using its advertised peak of 15 quadrillion dense NVFP4 operations per second and a 1.4-kilowatt power envelope, lands around 10.7 trillion operations per second per watt.

Under that particular set of assumptions, the brain is only about five times more efficient.

Only is doing a lot of work in that sentence. A neural event is not an NVFP4 operation. Peak specifications are not sustained performance. The brain mixes analog and digital functions, and much of its energy maintains a living system rather than executing matrix multiplication.

Put simply: there’s no clean exchange rate between a thought and a FLOP.

Still, the calculation is useful because it shows that raw compute efficiency is not separated by six or nine orders of magnitude.

How do we get to the promised land?

With better transistors, lower precision, sparsity, improved utilization, and hardware designed around AI workloads, a fivefold gap can disappear quickly.

Memory is harder. Much harder. This is where the brain’s engineering is still beyond what humans are currently capable of.

Depending on how we estimate synaptic activity and stored state, the brain’s effective bandwidth per watt may exceed a conventional GPU by hundreds or thousands of times. The exact number is debatable because the units are artificial. The architectural fact is not: the brain spends very little energy moving each piece of information because the distance is short and the communication is sparse.

The brain’s moat is not calculation raw power or even hyper-efficient compute.

It is locality. And that moat is collapsing at accelerating rates.

Silicon Is Learning Locality

The direction of AI hardware is already clear.

High-bandwidth memory places larger and faster memory stacks close to the GPU. Advanced packaging creates wider connections between processors and memory. Chiplets shorten communication paths between specialized components. Sparse models activate only the parts of the network needed for the current input.

Wafer-scale computing takes the idea further. NVIDIA’s B300 pairs up to 288 gigabytes of HBM3e with roughly 8 terabytes per second of memory bandwidth. Blackwell can deliver 15 petaflops of dense NVFP4 compute on a single GPU.

Cerebras uses a very different design. A very unique one.

Instead of cutting a wafer into many small chips and reconnecting them across a board, it turns nearly the entire wafer into one processor. Its WSE-3 contains 44 gigabytes of on-chip SRAM and advertises 21 petabytes per second of memory bandwidth. That is more than 2,600 times the B300’s HBM bandwidth, although SRAM and HBM serve different roles and the systems should not be treated as interchangeable. The point is what becomes possible when data stays on the same piece of silicon.

Cerebras has traded memory capacity for radical bandwidth. Forty-four gigabytes is enormous for on-chip SRAM, but it remains tiny compared with the estimated adaptive state in a brain or the memory needed to hold the largest models. The next step is to combine wafer-scale compute with far more local memory.

Imagine a three-dimensional Cerebras.

Instead of spreading compute and memory across a flat board, stack layers of dense memory directly over or under layers of logic. Connect them with huge numbers of short vertical links. Keep frequently used weights close to the arithmetic. Move less data across the package. Move even less across the rack.

This is not yet a solved product design. There are several problems being worked on by brilliant people in labs all across the planet. Stacking active components creates problems in heat, yield, power delivery, and manufacturing. Memory also involves tradeoffs among density, speed, durability, and precision. A beautiful architecture can fail when it must be manufactured by the million.

But the path forward (and upward) is real. Researchers have already demonstrated monolithic three-dimensional systems with multiple vertically integrated circuit tiers. Other teams are developing near-memory compute, analog in-memory operations, and new forms of nonvolatile memory that can store values and participate in computation.

The hardware roadmap is converging on the brain’s central trick.

Put memory where the work happens.

The Fifteen-Year Bet

Predictions about intelligence become slippery because people combine several different claims.

Hardware efficiency is not model capability. Model capability is not autonomy. Autonomy is not consciousness. A machine can outperform a person at economically useful work without thinking or feeling like a person.

So my forecast has three parts.

First, I expect a shipping AI accelerator to surpass the brain on at least one defensible measure of low-precision computation per watt by 2028/2029. Depending on how the brain-equivalent operation is defined, someone may plausibly claim this sooner. But within three years, the raw compute-efficiency case should become difficult to dispute.

Second, I expect stacked memory, wafer-scale systems, and near-memory computation to erase most of biology’s advantage in effective memory access within five years. This is the harder prediction. It depends less on faster arithmetic than on packaging, materials, heat removal, and the physical distance traveled by each bit. But AI is creating self-reinforcing loops across science and technology, and that make me confident we are already deep inside the singularity and can expect accelerating acceleration going forward.

Third, I expect AI systems to surpass humans across most economically valuable cognitive tasks within the same period.

That third prediction does not follow automatically from the first two. Intelligence is not a benchmark for hardware utilization. The brain has recurrence, embodiment, online learning, emotional signals, and evolved drives that current models do not reproduce.

But hardware parity removes one of the strongest reasons to believe biological cognition occupies an unreachable level.

AI also does not need to fit inside one skull-sized chip. A system can use many processors, external memory, retrieval, tools, and specialized models. It can copy itself, run in parallel, and spend far more than twenty watts when the result is valuable.

It can trade energy for speed in a way evolution could not.

Silicon may surpass the brain as a system before any single chip resembles one.

The Mind Is Moving Outside the Skull

The most important consequence is not that machines become more like us.

It is that we become less limited to ourselves.

Human beings have always extended cognition into the environment. That was one of our special evolutionary forces. Language let one mind shape another. Writing externalized memory. Mathematics externalized formal reasoning. Institutions allowed groups to hold knowledge and coordinate action beyond the capacity of any member. Software externalized repeatable procedure.

AI externalizes parts of cognition itself.

A book can preserve an idea, but it does not adapt the idea to your situation. A database can store facts, but it does not decide which facts matter. A spreadsheet can execute rules, but it does not usually rewrite the rules after examining the outcome.

Models can transform information. They can compare, draft, critique, explain, search, simulate, and act. Connected to tools and persistent memory, they can carry work across hours or days. They can hold several competing interpretations while the human chooses among them.

The model alone is not the external mind.

The system around the model is.

The model generates possibilities. Memory preserves context. Tools let it affect the world. Permissions define what it may touch. Evaluations detect failure. Workflows give it continuity. Human judgment supplies goals and decides what deserves to survive.

A wild thing to think about: that stack above changes the unit of thought itself.

The old unit was the individual mind → one brain, one working memory, one stream of conscious attention.

The new unit is a person surrounded by models, memories, tools, and agents. A research agent can explore the literature while a coding agent tests an implementation and an operating agent monitors the system. The person no longer performs each cognitive step. They shape the environment in which cognition happens.

This is more than productivity software.

It’s a new cognitive architecture.

The boundary of the mind has always been porous. AI makes that porosity operational. Parts of what we remember, notice, compare, and produce will live outside the brain but remain available as extensions of our agency.

The skull stops being the practical boundary of the mind.

The Bottleneck Moves Up the Stack

When compute is scarce, intelligence looks like producing an answer.

When compute becomes abundant, intelligence looks like choosing what should be answered.

This is the deeper shift. AI will make competent cognitive output cheap. It will become easy to create ten analyses, one hundred designs, or one thousand possible strategies. More systems will be able to code, write, plan, negotiate, and research at a level that once required trained specialists.

Abundance does not remove scarcity. It moves it.

Answers become abundant. Good questions remain scarce.

Output becomes abundant. Taste remains scarce.

Analysis becomes abundant. Commitment remains scarce.

Memory becomes abundant. Attention remains scarce.

Intelligence becomes abundant. Agency remains scarce.

The advantage will belong to people who can build and direct a cognitive system without losing themselves inside it. They will know how to divide work among models, create feedback loops, preserve useful context, test uncertain claims, and apply judgment at the points where mistakes matter.

They will not compete with AI by trying to think every thought manually.

They will decide which thoughts are worth having.

Build a Mind You Still Control

There is an optimistic version of this future in which people gain extraordinary leverage.

A capable individual can draw on more knowledge, explore more options, and build more ambitious things than a large organization could manage before.

There is also a dangerous version we need to talk about.

The systems that remember for us and reason with us will influence what we notice. The models that summarize the world will shape which parts of the world remain visible. If we outsource not only execution but also goals, standards, and judgment, greater intelligence can produce weaker agency.

Cognitive leverage without cognitive sovereignty is dependency.

The practical response is not to reject artificial intelligence. It is to become deliberate about the mind you are assembling around yourself. Use it for leverage but don’t let it do your thinking for you.

Own important context. Know which systems can read it. Keep evidence attached to consequential claims. Use multiple attempts when uncertainty is high. Preserve the ability to inspect the work. Automate execution aggressively, but be careful about automating your goals.

The most valuable human skills will sit above raw cognition: choosing objectives, forming values, reading consequences, building trust, exercising taste, and accepting responsibility for a decision.

Those are not consolation prizes left over after machines take the real work.

They are the control layer.

The human brain is still the most remarkable general-purpose thinking system we know. It holds an enormous amount of adaptive state, learns from sparse experience, and runs continuously on about twenty watts.

But its lead is not infinite.

Frontier models are already within a few orders of magnitude of the brain’s estimated synaptic scale. AI chips are within striking distance under some measures of raw compute per watt. The remaining hardware moat is memory locality, and nearly every important trend in advanced chip design is aimed at moving less data across shorter distances.

Silicon will catch the brain.

When it does, that will not mark the end of the human mind. It will mark the end of the skull as the mind’s practical boundary.

Our advantage will not be that we can produce more thoughts per second. It will be that we can decide which thoughts deserve attention, which systems deserve trust, and what all that intelligence is for.

The future of the mind is larger than the brain.

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

We did not claim that a theorem had been reproduced. We did not claim that the source census was complete. We did not claim a new mathematical result.

We had proven something much narrower.

CORTEX could take a frozen research mandate, process the evidence, reproduce a defined result, preserve the chain of custody, and stop at the boundary of what the evidence justified.

That might not sound dramatic for a few reasons.

It did not solve an open problem.

It did not discover a new construction.

It did not produce the kind of result that generates headlines about artificial intelligence transforming science.

But it demonstrated a capability that most AI systems still lack.

The ability to know when they have not proven something. And in a world of hallucinations and half-truths, if you want to use the power of AI you need rigid boundaries and verifiable truths to conduct new science.

What We Are Building

CORTEX is an experimental AI-native research system.

Computational Operations for Research, Thesis, Evidence, and eXperimentation.

It is not a model. It’s not a chatbot with a longer prompt. It’s not a single autonomous agent that receives a question and returns something resembling a research paper.

CORTEX is the machinery around the models.

It converts a research mandate into bounded work. It assigns specialized workers to gather evidence, reproduce results, generate candidates, run tests, and attack conclusions. Managers allocate budgets and decide what deserves further attention. Critics search for leakage, weak controls, hidden assumptions, and alternative explanations. Gates determine whether the evidence supports another experiment, a larger claim, or no further action at all.

Every consequential action is supposed to leave a receipt. That’s one of the big breakthroughs in this design.

The system records the source material, tool versions, input hashes, transformations, costs, outputs, objections, decisions, and unresolved questions. It maintains a ledger so that later workers do not have to reconstruct what happened from a polished summary or trust the memory of another model.

Humans remain outside and above this machinery. We choose the mandate. We set the budget. We define the authority boundaries. We decide which claims may leave the lab.

The metaphor I keep returning to is a smart factory.

The models are workers on the factory floor. Some are fast generalists. Some are narrow specialists. Some build. Some inspect. Some try to break what the others produced (they are my favorite).

But workers alone do not make a factory.

A factory also needs work orders, raw-material controls, managers, quality systems, safety rules, accounting, maintenance, and executives who decide what may ship. Without that surrounding structure, adding more workers may increase output without increasing quality.

Research has the same problem.

A larger swarm can produce more hypotheses, more experiments, more critiques, and more prose. It cannot guarantee that any of those outputs deserve belief. Machine effort is becoming abundant. Independently validated knowledge remains scarce.

CORTEX is our attempt to build the conversion layer between the two.

The Frontier Problems Lab, a venture formed by McDonagh Family Office, is the institution we are building around that system. Its destination is a research lab designed to attack problems that resist ordinary workflows. The aim is not to stage impressive conversations with artificial intelligence. It is to learn whether a closed-loop machine institution can turn large amounts of bounded computational and cognitive effort into small amounts of defensible knowledge.

That requires more than discovery.

It requires reproduction, falsification, provenance, memory, independent review, explicit non-claims, and the ability to stop. It requires a system that can distinguish an interesting candidate from a validated result and a validated result from something ready to publish.

After building v1 of the system we began this effort with a calibration run.

Before asking CORTEX to discover something new, we asked it to reproduce something narrow and already defined. Before testing its creativity, we tested its discipline.

Before giving it freedom, we tested whether it could operate inside a contract.

The first question was not whether CORTEX could solve a frontier problem.

It was whether CORTEX could reliably know what it had done.

That is how we arrived at the 56 records.

The Most Dangerous Word in AI Research

The most dangerous word in AI research may be “success.”

We use it to describe too many different things.

A model returned an answer. Success.

An agent completed a workflow. Success.

A program ran without crashing. Success.

An experiment produced the expected number. Success.

A result matched a published table. Success.

A candidate survived a backtest. Success.

These events may all matter. But they do not mean the same thing.

A completed task is not necessarily a correct task. A reproducible result is not necessarily a true result. A true result is not necessarily a novel result. A novel result is not necessarily an important result.

Each step requires different evidence.

When those distinctions disappear, activity becomes confused with progress. More tokens, more agents, more experiments, and more documents create the appearance of a research program without establishing that anything has actually been learned.

This is especially dangerous with modern AI because the output is so persuasive. The model does not merely produce an answer. It produces an answer in the language of expertise. It explains, qualifies, cites, summarizes, and often sounds more certain than the available evidence warrants.

Fluency compresses uncertainty.

That makes the surrounding system more important, not less.

The model can generate possibilities. The research institution must determine what those possibilities mean.

What We Actually Asked CORTEX to Do

The first Frontier Problems Lab run was intentionally modest.

We did not ask CORTEX to solve a famous open problem. We did not ask it to invent a proof or search for a new geometric construction. We did not unleash a swarm of agents on an ambiguous mandate and hope that something interesting emerged.

The job was simple:

Take the frozen source artifacts. Verify their hashes. Parse the records. Reproduce the expected counts. Compare the result with the frozen table. Record exactly what happened.

This was not a test of advanced mathematical creativity. It was a test of whether the research machinery could follow an evidence contract.

That distinction was deliberate.

Before building a system that searches for new knowledge, we wanted to know whether it could reliably handle old knowledge. Before asking it to generate hypotheses, we wanted to know whether it could preserve inputs, execute a bounded mandate, produce receipts, and respect a claim boundary.

Discovery is built on reproduction.

If the system cannot reliably tell us what entered the factory, what operations were performed, what came out, and which claims follow from the result, then adding more intelligence merely increases the speed at which uncertainty is manufactured.

The Run Worked

The run passed.

The expected 56 records were present. The machine-readable source artifacts matched their frozen cryptographic hashes. The record distribution matched the expected contract. The edge totals matched. All 22 rows in the comparison table were reproduced.

The evaluator reached the expected conclusion: the baseline had been reproduced for artifact integrity.

That sentence matters because of what it does not say.

It does not say the underlying mathematical objects were correctly represented in every respect. It does not say every graph in the census has the required geometric properties. It does not say the census is complete. It does not validate the theorem, proof, or broader claims associated with the source.

It says the frozen artifacts were processed consistently and reproduced according to a defined contract.

Nothing more.

This is where many AI research demonstrations would begin expanding the story. The reproduction would become “validation.” The validation would become “verification.” The verification would become evidence that the AI understood the mathematics. By the time the result reached a headline, a successful data-processing exercise might be described as an autonomous mathematical achievement.

We did the opposite.

We narrowed the claim until it fit the evidence.

Reproducibility Is Not Truth

Reproducibility is essential to science, but reproducibility and truth are not synonyms.

A system can perfectly reproduce an error.

It can reproduce a flawed dataset, a mistaken assumption, an incomplete census, a transcription problem, or a test that measures the wrong thing. It can execute an invalid method with flawless consistency.

Reproduction answers one question:

Can the result be generated again under the stated conditions?

Truth demands a lot more.

Were the inputs valid? Did the method test what it claimed to test? Were relevant alternatives excluded? Did hidden assumptions shape the result? Does the conclusion survive independent attack? Does the evidence support the scope of the claim?

Those are separate questions.

Our first run established that CORTEX could reproduce a frozen artifact-level result. It did not establish the broader mathematical truth surrounding that artifact.

That was not a weakness in the experiment. It was the point of the experiment.

A credible research system must preserve the distance between what happened and what can be claimed about what happened.

The System Stopped Safely

The most important output of the run was not the reproduced table.

It was the hold.

CORTEX reached the end of its authorized mandate and did not convert a narrow reproduction into broader research authority. It did not begin searching for new constructions. It did not promote the result into a discovery claim. It did not treat the absence of an error as evidence of mathematical truth.

The candidate remained held.

This is easy to overlook because we are accustomed to measuring systems by what they produce. More answers. More candidates. More code. More experiments. More speed.

But in research, restraint is a productive capability.

A system that can generate a thousand hypotheses but cannot stop itself from overstating weak evidence is not an advanced research system. It is an industrial-scale speculation machine.

A system that can recognize the limit of its evidence is more valuable.

Stopping is not the absence of an output.

Stopping is an output.

It says the available evidence supports this claim and not the next one. It says the next action requires a different mandate, stronger evidence, or additional authority.

It preserves the value of what was learned without pretending that more was learned.

The Model Was Not the Researcher

The run also reinforced a broader lesson about artificial intelligence.

The model is not the research system.

The system included a frozen mandate, source artifacts, cryptographic hashes, a mathematics adapter, deterministic checks, expected outputs, non-claims, resource limits, authority boundaries, a gate decision, and a durable evidence record.

The model was one component inside that architecture.

This is a different way of thinking about AI.

The chatbot frame trains us to focus on the exchange between a person and a model. The person asks a question. The model produces an answer. We judge the answer by reading it.

That frame becomes inadequate as AI moves into consequential work.

Research is not one answer. It is a chain of actions, transformations, tests, judgments, and claims. Each step creates opportunities for error. Each transition needs a contract. Each claim needs evidence. Each expansion of authority needs a gate.

The question is no longer merely whether the model is intelligent enough.

The question is whether the institution around the model is disciplined enough.

Receipts Before Reputation

Human institutions use reputation as a shortcut.

We trust a result partly because of who produced it, where it appeared, who reviewed it, and whether the surrounding institution has earned credibility over time.

An AI-native research institution begins without that accumulated trust.

It must earn credibility another way.

Receipts before reputation.

What were the exact inputs? What were their hashes? Which tools and versions were used? What transformations occurred? What budget was consumed? Which controls ran? What failed? What remained unresolved? What decision was reached? What authority was explicitly withheld?

These records are not administrative debris. They are part of the research product.

The polished paper may eventually explain the result. The ledger explains how the result came to exist.

This matters because AI makes cognitive labor abundant. A machine can produce more hypotheses, analyses, critiques, simulations, and manuscripts than a human team could reasonably inspect.

When production becomes cheap, selection becomes expensive.

When answers become abundant, provenance becomes scarce.

When persuasive language becomes automatic, disciplined claims become a competitive advantage.

The bottleneck moves from generating work to establishing which work deserves belief.

More Agents Do Not Solve This

The popular response to the limits of one model is to add more models.

One agent researches. Another critiques. Another manages. Another votes. Perhaps a larger swarm will converge on the truth.

Sometimes that helps. Different models can find different errors. Specialized workers can handle different tasks. Parallel exploration can search a larger space.

But a swarm is not automatically an institution.

Ten agents can repeat the same assumption ten times. They can share the same contaminated context. They can reward one another’s fluency. They can converge because they were prompted similarly, trained similarly, or shown the same intermediate conclusions.

Agreement is not independence.

A useful multi-agent research system must engineer the conditions under which disagreement can matter. Reviews should be isolated when appropriate. Critics should receive explicit falsification mandates. Inputs should be frozen. Outputs should be committed before comparison. The final evaluator should not silently rewrite the work it is supposed to judge.

The system needs workers.

It also needs managers, critics, auditors, executives, and a ledger.

And those roles must differ in authority, not merely in prompt wording.

Evidence Needs Gates

Building this has been exciting and humbling. A major early learning: boundaries are key!

We initially treated several different questions as if they belonged to one gate.

Was the research evidence sound?

Was an external credibility claim justified?

Was a website operationally safe to publish?

Should the next research campaign be authorized?

Those questions are related, but they are not the same.

Coupling all of these questions creates institutional confusion. It allows an unresolved publication task to halt research, or a narrow research result to inherit public-release authority it never earned.

The solution is separate gates.

A Research Evidence Gate asks whether the evidence supports the stated research conclusion.

A Credibility Gate asks which external credibility claims are justified.

A Publication Gate asks whether a specific release is safe and responsible to publish.

A Plaanning Gate asks whether the next bounded discovery campaign should be authorized.

Different evidence. Different decisions. Different authority.

This separation makes the system both safer and faster. Safety comes from preventing authority from leaking between domains. Speed comes from allowing local research to continue without waiting for unrelated publication work.

Good governance should not merely stop bad actions.

It should make legitimate actions easier.

The Economics of Machine Research

The deeper reason this architecture matters is that AI is changing the economics of research.

Machine effort is becoming cheap.

A model can read thousands of pages, generate candidate mechanisms, write test harnesses, search parameter spaces, run adversarial critiques, and produce structured evidence packages. Multiple workers can operate in parallel. Failed approaches can be recorded and reused. The institution can learn which kinds of experiments produce information and which merely consume budget.

This creates enormous leverage.

It also creates a new failure mode: cheap work can overwhelm expensive judgment.

The future research bottleneck will not be the number of ideas we can generate. It will be the number of claims we can validate.

The winning institution will not be the one with the largest swarm. It will be the one that converts machine abundance into scarce, independently tested knowledge with the least waste, the clearest lineage, and the strongest claim discipline.

That is the factory we are trying to build.

CORTEX is not meant to be an oracle. It is meant to become part of an operating system for research: workers producing evidence, managers allocating effort, critics attacking results, gates controlling authority, and a ledger preserving institutional memory.

The objective is not to make the machine sound more confident.

The objective is to make the institution more trustworthy.

What Our First Run Really Proved

So what did the first run prove?

It proved that CORTEX could accept a frozen artifact-level reproduction mandate.

It proved that the system could verify source hashes, parse the expected records, reproduce the specified table, and create a deterministic result.

It proved that the system could state the result narrowly.

It proved that the surrounding controls could preserve explicit non-claims.

It proved that the run could end without unauthorized continuation.

That is not mathematical discovery.

It is infrastructure for mathematical discovery.

There is a temptation to skip this layer because it is less exciting than asking a powerful model to attack the frontier. But foundations become more important as the machinery above them becomes more capable.

A weak model inside a disciplined system may produce limited results.

A powerful model inside an undisciplined system can produce convincing fiction at industrial scale.

We would rather begin with the discipline.

Knowing What We Know

AI research will produce genuine breakthroughs.

Models will find patterns humans missed. Agent systems will search spaces too large for conventional teams. Machine-generated conjectures, experiments, proofs, counterexamples, and designs will become normal parts of serious research.

But the volume and persuasiveness of the output will create pressure to move faster than the evidence.

That is why our first successful run mattered.

Not because it solved something.

Because it established a boundary.

The records matched. The hashes matched. The evaluator agreed. The machine completed its mandate.

And the institution still said: this does not prove the geometry.

That sentence contains the beginning of a credible AI research lab.

1. Intelligence generated the work.

2. Architecture constrained the claim.

3. The ledger preserved the evidence.

4. The gate withheld authority.

5. And human judgment remained in command.

Our first successful AI research run proved almost nothing.

It showed us that we might be building a system capable of knowing exactly what that means.

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

Past a certain capability threshold, the marginal quality of the model matters less than the quality of the context you feed it.

This sounds like heresy to the leaderboard crowd.

It is not. It is production reality.

For the last two years, everyone has been hypnotized by model deltas. This model is 4% better on a benchmark. That model has stronger reasoning. This one codes better. That one has a larger context window. This one is cheaper. That one is more agentic.

This one has better tool use. That one wins on vibes.

Fine.

Model quality matters. No doubt about it.

But once a model is sufficiently capable, the limiting factor shifts.

The bottleneck is no longer raw intelligence. Our middle-of-the-road laptops in 2027 will have open source AI capabilities that exceed today’s GPT 5.5 / Opus 4.8 threshold.

The bottleneck is whether the system knows what the hell is going on.

A brilliant, bleeding-edge model with bad context is a genius dropped into a dark room and asked to perform surgery with rumors.

A somewhat strong model with excellent context is a trained operator with the right file, the right tools, the right patient history, the right constraints, the right objective, and the right feedback loop.

Bet on the second system.

Every time.

The Threshold Changes the Game

Below the capability threshold, model quality dominates.

If the model cannot reason, cannot follow instructions, cannot use tools, cannot write coherent code, cannot hold structure, cannot understand ambiguity, cannot recover from errors, then context will not save it. You can hand a weak model perfect documentation and still get garbage.

There is a floor.

Intelligence must clear it.

But once the model clears that floor, the curve changes. The next upgrade still helps, but not in the same explosive way. The fifth leap in model quality does not create the same returns as the first. The gains begin to compress.

This is diminishing marginal return.

A model going from incompetent to useful is a revolution.

A model going from very good to slightly better is an optimization.

But context quality behaves differently.

Give the system better customer history, better examples, better domain rules, better retrieval, better tool outputs, better workflow state, better constraints, better preferences, better definitions of success, and the output often improves immediately.

Not because the model got smarter.

Because the model got situated.

It finally knows the game it is playing.

This is why context has roughly linear returns across a huge range of practical work. In some systems, it may even look superlinear, because good context unlocks latent capability that was already inside the model.

The model was not missing intelligence. It was missing the map.

Model V.S. Context

A lot of “model gains” people report are not model gains.

They are context gains wearing a “model costume”.

A team switches models and performance jumps. Everyone praises the new model. But what actually changed?

They rewrote the prompt.

They cleaned the input.

They added examples.

They improved retrieval.

They gave the model better schemas.

They added chain-of-workflow state.

They included user preferences.

They constrained the output.

They added a review step.

They improved tool descriptions.

They removed noisy documents.

They gave the system a clearer objective.

… then they say, “The new model is amazing.”

Maybe. Maybe not. I think we’re seeing several forces at the same time.. each of them accelerating us faster into the singularity.

Let’s talk about this, and the impact it has on the path forward for AI.

Read more

Not because it settles which model is “best.” It doesn’t… although some pretty obvious trends are emerging.

The point is that “best” is now too small a word.

Best for what task?

Inside what harness?

At what price per completed unit of work? On whose codebase?

The AI industry spent the last few years arguing about model leaderboards.

Databricks is pointing at something more useful: task-level economics inside real work. Their internal benchmark tested coding agents on actual engineering tasks drawn from Databricks’ own multi-million-line codebase, across the cross-language messiness that makes enterprise software real.

This is not a toy benchmark asking a model to solve clean public problems. It is closer to the thing companies actually care about:

Can this agent change our code, pass our tests, follow our conventions, respect our constraints, and do it cheaply enough that we stop rationing its use?

Because the future of software work will not be decided by model taste alone.

It will be decided by cost per shipped task.

The Unit of Work Has Changed

I’ve run engineering teams and groups of builders for the last 15-years. In many ways, it used to be more simple.

The old software productivity equation was: how many engineers do we have, how good are they, and how well do we coordinate them?

The new equation is stranger: how many agent attempts can we afford to run, how well can we route them, and how quickly can humans judge and integrate the results?

Databricks built its benchmark from merged pull requests. That detail matters. A pull request is not just a diff. It is a compressed unit of organizational knowledge: intent, code, tests, review, build context, and the hidden social fact that a team decided this work was good enough to ship.

That makes it a much better raw material for evaluating coding agents than synthetic puzzles. Public benchmarks are useful, but they age. They leak. They get trained on. They also tend to flatten the task into something cleaner than daily engineering work really is.

Databricks did something more grounded. They pulled from recent internal history, filtered out bot and generated work, looked for self-contained changes with tests, rewrote task descriptions so the model saw the goal rather than the solution, then judged the result by whether held-out tests passed.

They also avoided the evaluation trap that is quietly poisoning a lot of AI discourse: they did not use an LLM judge as the primary arbiter of correctness.

That matters because the goal is not to impress a model with a plausible explanation. The goal is to ship working software.

This is the first lesson from the benchmark: stop benchmarking vibes. Benchmark outcomes.

The Model is Not The Product

The most interesting result from Databricks is not that one model won.

It is that no single axis explains the outcome.

Their findings show a Pareto frontier that includes OpenAI, Anthropic, and open models. That alone is significant. Frontier coding performance is no longer a private two-company story. It is becoming a mixed ecology.

The benchmark also showed rough capability tiers. The top models are good across hard tasks, but they are expensive. Medium and smaller models can handle a lot of common work at much lower cost. That should change how engineering organizations deploy AI immediately.

Most companies still behave as if every task deserves the most expensive model they can access. That feels safe because the premium model is usually strong. It is also economically incoherent.

Not every task is a research problem.

Some work is changing a config. Some work is updating a test. Some work is tracing a simple bug. Some work is designing a migration path across three services without breaking the build.

This is where agentic software starts to look less like chat and more like operations. The important capability is not “which model do you like?” It is routing. It is knowing when to send the task to a cheap model, when to escalate to a frontier model, when to run three agents in parallel, when to ask a human for context, and when to stop because the test signal is not good enough.

The model is one part of the system.

The harness is the agent.

By harness, I mean the execution environment around the model: context selection, file access, tools, memory, permissions, shell commands, diff handling, tests, retries, branch management, and review loops.

Databricks found that the same model, with similar thinking effort, could have materially different cost and efficiency depending on the harness. In some cases, cost per task differed by more than 2x while quality stayed roughly the same.

That is not a footnote.

That is the product.

For the last year, everyone has been arguing about model intelligence. The Databricks benchmark says something more operational: intelligence without context discipline is expensive.

This is what every enterprise needs to internalize: the agent is the model plus the operating system around it.

Cost per Token is Broken

The benchmark also attacks one of the most common mistakes in AI budgeting: treating price per token as a proxy for price per task.

That frame is too tight and misses the full picture.

A cheaper model can become more expensive if it reads more, loops longer, retries poorly, drags in too much context, or fails often enough that humans have to repair the output. A more expensive model can be cheaper if it reaches the right answer quickly.

Databricks gave a clean example. Sonnet 5 was cheaper per token than Opus 4.8, but on their tasks it cost more per completed attempt while scoring lower. The reason was behavior. It consumed more tokens to get to a worse result.

This is the metric shift: do not ask what the model costs.

Ask what the completed task costs.

That is the number founders, CTOs, and operators should care about. If an agent fixes a bug, writes a migration, updates documentation, and passes the right tests, token line items are just ingredients. The unit that matters is the finished piece of work.

This is why every serious company will eventually build its own benchmark. Public benchmarks could not answer the question Databricks actually had, because Databricks does not run a public benchmark company. It runs Databricks. Its codebase, build graph, engineering patterns, and task distribution are the reality that matters.

That is true for every company.

If you have a backlog of merged PRs, you have the raw material for an internal agent benchmark. You can measure which tools solve your work. You can price them at the task level. You can see which models are overkill, which are underrated, and which harnesses quietly burn money by spraying context everywhere.

The companies that do this will compound.

The companies that do not will keep buying AI by brand.

GLM Is Bad News for American Models

The headline result is that GLM-5.2 landed in Databricks’ top capability tier. It was statistically tied with Opus 4.8 on quality in their benchmark, while costing less per task.

That is a big deal. Massive actually.

Not because one benchmark proves GLM is universally better. It does not. The honest read is narrower and stronger: on a serious internal coding benchmark from one of the most technically sophisticated software companies in the world, a lower-cost Chinese open model performed like a daily-driver coding model.

That is exactly the kind of evidence that changes buyer behavior.

In my piece, GLM-5.2 Proves AI Comes for All Moats I argued that GLM matters because it attacks the scarcity story underneath Western AI valuations. Premium labs need the market to believe frontier intelligence will remain scarce, expensive, proprietary, and defensible. They need “best model” to become “best business.”

GLM does not kill that argument, but it does compresses it.

If an open or open-ish Chinese model gets close enough on real coding work, the buyer’s question changes. It is no longer “who has the most prestigious model?” It becomes “why am I paying the frontier tax for this workload?”

Sometimes the answer will be good. Enterprises will still pay for trust, support, indemnity, governance, data controls, integrations, uptime, multimodal polish, and ecosystem maturity.

Premium models will still matter for the hardest work. But not every workload needs the sacred object.

And “not every workload” is where the economic damage begins.

If GLM can handle a meaningful share of coding tasks at lower cost, it does not need to beat OpenAI or Anthropic at everything. It just needs to be good enough on enough work to change the routing table.

That is how markets reprice.

Not all at once. Not with one dramatic replacement. Through thousands of small substitutions.

A config change goes to GLM. A test update goes to GLM. A medium bug fix goes to GLM. A migration plan starts with GLM, escalates to a premium model for design review, then returns to GLM for implementation attempts.

Suddenly the premium lab is not the default.

It is the escalation path.

That is a very different business.

Chinese Efficiency vs American Muscle

The uncomfortable American lesson is not just that Chinese models are catching up.

It is that they are catching up differently.

Western AI culture has been dominated by scale: more compute, bigger clusters, deeper capital pools, premium APIs, and a belief that the frontier can be held by whoever spends the most.

China has been forced into a different game. Sanctions, chip constraints, competitive pressure, and lower pricing power create a harsher environment. That environment rewards efficiency: architectural tricks, distillation, routing, context management, serving optimization, and ruthless price-performance thinking.

There are legitimate questions about Chinese labs that I’ve called out many times before. We know Chinese models benefit from Western outputs. Distillation and synthetic data are everywhere. There will be fights over originality, fairness, export controls, national security, and whether closed labs are funding the research that commoditizes their own products.

Those questions matter.

But they do not erase the market effect.

Customers buy outcomes. If a model solves the task, runs inside the workflow, can be self-hosted, and costs a fraction of the alternative, the origin story becomes secondary for many workloads. Not irrelevant. Secondary.

This is why GLM-5.2 showing up strongly in the Databricks benchmark matters more than a vendor leaderboard. Real-world internal evidence is harder to wave away.

It says the price-performance curve is moving into production reality.

That is the thing to watch.

Self-Hosted Frontier Models

The next phase is not just cheaper API calls.

The next phase is capable self-hosted models doing frontier-level work inside private systems. That changes the adoption curve. Many companies have not fully deployed coding agents because their code is sensitive, their compliance posture is strict, or their executives do not want proprietary source flowing through external systems.

Self-hosted capable models create a different option.

Now the company can run agents inside its own perimeter. It can inspect logs, constrain permissions, connect to internal systems, benchmark every model against its own repo, and run background agents against tech debt, flaky tests, dependency upgrades, security issues, documentation drift, and migration plans.

This is where the abundance shift becomes real.

When intelligence is expensive, you ration it. You use the premium agent for high-value work. You wait for the human to decide the task is worth spending tokens on. You keep the number of attempts low.

When intelligence is cheap and local, you stop asking whether a task deserves an agent.

You ask how many agents should try. You move from chatting to commanding a fleet of AI agents.

That changes software operations. Every issue can get a first-pass investigation. Every pull request can get multiple independent reviews. Every flaky test can get a background repair attempt. Every security advisory can be mapped against the actual codebase before a human opens the ticket.

This does not remove engineers.

It changes what engineering management is.

The bottleneck moves from typing code to designing work systems. The scarce skills become judgment, taste, architecture, review, evaluation, and the ability to define tasks clearly enough that agents can execute them.

This is why the Databricks methodology is so important. The benchmark is not just a report. It is a template for governing agentic labor.

Capture real work. Convert it into tasks. Hold back the answers. Test outcomes. Seal obvious leakage paths. Compare cost per task. Route accordingly. Repeat as models change.

That is the operating system.

Routing is Winning

In the model-scarcity world, the winner is whoever has access to the smartest model.

In the model-abundance world, the winner is whoever allocates intelligence best.

That means routers. Not just technical routers that send prompts to models based on cost and latency, though those matter. I mean organizational routers too: systems that decide which work should be automated, parallelized, escalated to a senior human, delegated to a cheaper model, or wrapped in a full audit trail.

The Databricks benchmark points directly toward this future. It does not say, “we found the one model everyone should use.” It says the frontier is a portfolio: a mix of tools, models, and harnesses, measured against real tasks.

That is the mature frame.

It also tells us where software companies should invest. Do not just buy seats. Build the measurement layer. Build the eval set. Build the model router. Build context discipline. Build permission boundaries. Build internal datasets from your own PRs. Build cost dashboards that show dollars per successful task, not just tokens per vendor.

The companies that get this right will not merely use AI. They will make AI legible.

And once intelligence becomes legible, it becomes manageable.

Once it becomes manageable, it becomes a line of operations.

The Moat Is Moving

The mistake is thinking this means moats disappear.

They do not.

They move.

The moat is less likely to be “we alone have the model.” That moat is getting shorter. Capability diffuses. Open models improve. Chinese labs optimize. Distillation compresses. Costs fall.

The new moats are closer to the work.

Who has the best proprietary evals? Who has the cleanest internal workflow data? Who can route tasks most efficiently? Who has the tightest harness? Who can make cheap intelligence reliable enough to trust?

That is better for builders and worse for anyone relying on scarcity premiums.

The Databricks benchmark is important because it makes this concrete. Coding agents are not a demo category anymore. They are an operating expense, a labor layer, and a routing problem. Open models are not just philosophical alternatives. They are entering the daily-driver conversation. The task, not the token, is the economic unit.

Most importantly, it shows that companies do not need to wait for the market to tell them what works.

They can measure it themselves.

That is the real frontier now.

Not a single model. Not a single lab. Not a single benchmark.

The frontier is the ability to convert cheap, abundant, increasingly local intelligence into reliable work.

GLM-5.2 is one signal. Databricks’ benchmark is another. Together they point in the same direction: the age of paying blindly for premium intelligence is ending. The age of managing intelligence as infrastructure is beginning.

And once self-hosted open models can do frontier-level work, the question stops being whether AI can help.

The question becomes whether your organization knows how to spend intelligence well.

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

That is not the scarce thing anymore.

The scarce thing is knowing where to put it, who should use it, how the work should change, and what platform needs to exist underneath it so the gains actually compound.

Most companies are still treating AI like a tool decision. They ask which model to buy, which chatbot to deploy, which copilot to enable, which vendor to trust. Those questions matter, but they are not the main question.

The main question is simpler and harder:

Where can AI create leverage in the operating system of the company?

That is the offering I developed at RevSystems.

We help companies move from scattered AI experimentation to measurable operating leverage by aligning People, Processes, and Platforms around the work that matters most.

The tool frame is too small. AI does not create value because someone has access to a model. It creates value when a workflow changes. It creates value when a team can produce more with the same headcount, make better decisions with the same data, respond faster to the same market, or serve more customers without adding the same amount of operational drag.

The unit of change is not the prompt.

The unit of change is the workflow.

That is where most AI programs break. A company gives people tools, then waits for transformation to appear. Some people experiment. A few power users get faster. A few teams build clever internal demos. Leadership hears enough anecdotes to believe something is happening, but not enough evidence to know what changed.

Activity goes up. Leverage does not.

The reason is that AI adoption is not the same as AI leverage. Adoption means people are using the tool. Leverage means the business system is getting stronger.

Those are different games.

People

The first pillar is People, because AI changes the shape of work before it changes the org chart.

Every team now needs to answer questions it did not have to answer before. What work should remain human? What work should be delegated? Who reviews AI output? Who owns the final judgment? What level of quality is acceptable? What risks are tolerable? What skills now matter more than they did two years ago?

The winners will not simply be the companies with the most AI licenses. The winners will be the companies with the clearest human judgment loops.

AI increases the amount of work that can be attempted. That sounds purely positive until you see what happens inside a real company. More drafts. More analyses. More campaigns. More reports. More ideas. More automation. More noise.

Without better judgment, AI creates abundance without direction.

So the People work is not just training. Training is part of it, but training alone is too narrow. The real work is role design, decision rights, capability building, leadership behavior, and adoption discipline.

People need to know when to use AI, when not to use it, how to inspect it, how to improve it, and how to build repeatable ways of working with it. Managers need to know how to evaluate output when production costs collapse. Leaders need to know how to set priorities when every team can suddenly generate more work than the company can absorb.

This is the human side of leverage.

Not inspiration. Not generic enthusiasm. Operating clarity.

Process

The second pillar is Process, because AI does not belong on top of broken workflows.

If a process is slow, vague, political, duplicative, or poorly measured, adding AI often makes the dysfunction faster. It can accelerate confusion. It can produce cleaner-looking artifacts from the same bad inputs. It can give leadership the feeling of progress while the underlying system stays stuck.

The right move is to redesign the workflow around human-AI collaboration.

That means mapping how work actually moves. Where does demand enter the system? Who touches it? Where does it wait? Where does quality get checked? Where does context get lost? Where are people doing manual translation between systems? Where are high-value employees spending time on low-judgment tasks?

Then we ask: what should AI draft, search, summarize, compare, enrich, route, monitor, recommend, or execute?

This is where the value of AI starts to become concrete.

A sales team does not need AI. It needs faster account research, cleaner follow-up, better call prep, sharper deal inspection, and less manual CRM hygiene.

A customer success team does not need AI. It needs earlier risk detection, better renewal preparation, faster knowledge retrieval, and more consistent customer communication.

A finance team does not need AI. It needs variance explanations, scenario analysis, policy checks, and less spreadsheet archaeology.

A leadership team does not need AI. It needs a better operating cadence, faster synthesis, and clearer visibility into what is actually happening.

The process lens turns AI from a vague capability into a practical redesign of work.

Platform

The third pillar is Platform, because AI leverage depends on the machinery underneath the workflow.

This is the part many executives underestimate. They see the model and miss the system. But the model is only one layer. The real platform includes data access, permissions, integrations, memory, evaluation, security, workflow orchestration, reporting, and governance.

A model without context is a guessing machine.

A model with the right context, tools, permissions, and feedback loops becomes part of the company’s operating infrastructure.

That does not mean every company needs a giant AI platform build. Most do not. But every company needs to know whether its current technology stack can support the workflows it wants to change.

Can the AI access the right data? Can it act inside the right systems? Can it respect permissions? Can it be monitored? Can the output be evaluated? Can humans intervene? Can the workflow be repeated? Can the gains be measured?

If the answer is no, the company does not have an AI strategy. It has a collection of experiments.

The Platform work is about making the technology stack usable for leverage. Sometimes that means cleaning up CRM data. Sometimes it means connecting knowledge systems. Sometimes it means designing agent workflows. Sometimes it means choosing fewer tools, not more. Sometimes it means creating a governance layer so teams can move faster without creating unmanaged risk.

The goal is not technological sophistication for its own sake.

The goal is operational power. Leverage.

Two Front Doors

There are two natural ways to bring this offering into the market.

The first is the CEO front door.

For CEOs, the message is enterprise leverage. AI is now a board-level operating question because it touches productivity, margin, speed, customer experience, and competitive position. The CEO does not need a tour of every tool. The CEO needs to know where AI can make the company meaningfully stronger.

The CEO discussions I have focus on different areas vs the Operators I speak with.

CEOs want to know: where are the three to five places AI can most improve the business? Where are we wasting human capacity? Where are we too slow? Where is quality inconsistent? Where are we blocked by data, process, or ownership? What should we do in the next 90 days?

The deliverable is not a glossy transformation deck. It is an operating roadmap: priority workflows, business cases, owners, metrics, governance, platform gaps, and first-wave pilots.

The second place I focus is Revenue Operations. I’ve been a RevOps Builder for years.

Mastering Revenue Operations

Engineering and building powerful and efficient revenue engines.

By Matt McDonagh

For RevOps, the message is revenue execution infrastructure. Revenue teams are full of hidden manual work. Lead routing, CRM hygiene, forecasting, territory planning, enrichment, campaign handoffs, pipeline inspection, QBR prep, renewal tracking, win-loss analysis, rep coaching, and customer segmentation all contain repeatable cognitive labor.

AI can help, but only if the revenue engine is designed for it.

It answers: where can AI reduce manual work, improve conversion, clean up data, speed up handoffs, and give leadership better visibility?

This is a practical buyer. RevOps does not want theory. RevOps wants cleaner systems, better process compliance, faster reporting, stronger forecast confidence, and fewer hours wasted moving information from one place to another.

The same People, Processes, and Platforms model applies. The entry point changes.

For the CEO, AI is operating leverage. For RevOps, AI is revenue leverage.

Both matter.

The Benefits of True AI Leverage

The benefits are straightforward because they map to the real constraints companies feel every day.

First, speed. AI can compress the time between question and answer, request and response, idea and draft, signal and action. But speed only matters when the workflow is pointed at something valuable.

Second, capacity. Teams can handle more work without adding the same amount of headcount. This does not mean replacing everyone. It means removing low-judgment work from high-judgment people so their time compounds.

Third, quality. AI can make good teams more consistent by giving them better first drafts, better checks, better retrieval, and better operating memory.

Fourth, visibility. When workflows become more structured, leadership gets a clearer view of where work stands, where bottlenecks form, and where the system is leaking value.

Fifth, scalability. A company that redesigns work around AI can grow without recreating every manual process at a larger size.

That is the real prize.

Not novelty. Not demos. Leverage.

The companies that win with AI will not be the ones that talk about it the most. They will be the ones that make the deepest changes to how work gets assigned, performed, reviewed, measured, and improved.

They will align their People so judgment stays sharp.

They will redesign their Processes so AI enters the real flow of work.

They will strengthen their Platforms so tools become infrastructure instead of clutter.

AI is not a magic layer you sprinkle across the company.

It is a new labor layer that has to be wired into the operating model.

That is why this offering exists. It gives companies a practical way to find the leverage, build the roadmap, and move from experimentation to execution.

The age of asking whether AI matters is over.

The only serious question now is where it belongs in the work.

If you would like my help designing and building your revenue engine and the rest of your business with AI, just reach out!

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

The argument was simple.

For most of modern history, specialization won. The world became too complex for one person to understand every domain deeply, so we built careers, companies, institutions, and status ladders around narrow expertise.

Then AI changed the terrain.

Suddenly the person with broad context, taste, judgment, and curiosity could command specialist intelligence on demand. The generalist was no longer limited by what they personally knew how to execute. They could stand above the system, understand the shape of the problem, and direct the specialists.

I used the metaphor of the conductor.

The specialist plays the violin. The model plays the cello. The analyst plays the trumpet. The engineer plays percussion. The conductor does not need to be the best at every instrument. The conductor needs to understand the music.

That was true. It’s still true.

But it is no longer big enough.

The instruments have started becoming workers.

The models no longer just answer. They inspect. They remember. They plan. They call tools. They browse files. They run commands. They test outputs. They compare approaches. They work in parallel. They continue across long-running threads. They take a messy objective and return an artifact.

This is the next phase.

The generalist won once by orchestrating specialist intelligence.

Now they win again by operating persistent agentic labor.

The Unit Of Work Has Changed

The chatbot era trained us to ask better questions.

The agent era trains us to assign better work.

That distinction sounds small until you feel it in practice.

A question produces a response. A task produces a result.

A workstream produces leverage.

This is the real shift. The important interface is no longer the prompt as a clever sentence. The important interface is the work order as a structured command.

Not:

“Explain this market to me.”

But:

“Research this market, identify the five most important companies, compare their business models, pull recent funding and revenue signals, find the key open questions, create a memo, and flag where the evidence is weak.”

Not:

“Help me write code.”

But:

“Inspect this repo, find the source of the bug, propose three likely causes, implement the safest fix, run the relevant tests, update the docs, and summarize the tradeoffs.”

Not:

“Give me ideas.”

But:

“Generate ten strategies, pressure test each one from the perspective of a customer, competitor, investor, and operator, then rank them by upside, feasibility, and time to impact.”

That is not a conversation.

That is delegation.

We’ve moved from chatting to commanding.

The prompt is becoming the work order. The thread is becoming the workspace. The agent is becoming the production unit.

This changes the economics of thinking.

For the first time, cognitive labor is starting to behave like cloud compute. You do not need to hire one human for every branch of exploration. You can spin up attempts. You can run variations. You can compare outputs. You can ask one agent to build and another to critique. You can ask one to research deeply and another to find what the first one missed.

The scarce resource is no longer the first draft.

The scarce resource is judgment.

From Conductor To CEO

The conductor metaphor was right for the age of model orchestration.

But the better metaphor now is the CEO.

Not the celebrity CEO. Not the corporate bureaucrat. The real CEO function.

Define the mission.

Allocate resources.

Choose the right people for the right work.

Create operating systems.

Review performance.

Kill weak projects. Double down on strong ones.

That is what high-agency people are learning to do with agents.

They are not asking AI one question at a time. They are building portfolios of attempts.

One agent explores the technical path.

One agent explores the market path.

One agent writes the memo.

One agent attacks the assumptions.

One agent turns the memo into a customer-facing artifact.

One agent builds the spreadsheet.

One agent checks the numbers.

One agent turns the whole thing into a decision.

The human is no longer the person doing every step directly.

The human is the person designing the system that does the work.

This is where the neo-generalist becomes extremely dangerous.

The specialist can use AI to go deeper inside a narrow domain. That is powerful.

But the generalist can use AI to coordinate across domains. That is more powerful. The generalist can move from strategy to code, from finance to product, from customer psychology to distribution, from legal structure to operational process, from narrative to execution.

Not because they personally replaced every expert.

Because they can now summon, supervise, and synthesize machine labor across the whole map.

That is the second revenge of the generalist. Wait til you see what AI harnesses are going to allow generalists to accomplish.

The Harness Is The Agent

The public still talks about models as if the model is the whole story.

That is wrong.

The model matters enormously. Better reasoning, better coding, better tool use, better multimodal understanding, lower cost, longer context, faster inference. All of that matters.

But the breakthrough is not just the model.

The breakthrough is the harness. Codex by OpenAI is the best harness on the market right now. It makes sense that OAI are focusing on operationalizing their models and creating leverage with them.

A model sitting in a chat window is intelligence trapped behind glass.

A model inside a harness can act.

It can read files. It can edit artifacts. It can run tests. It can call APIs. It can use a browser. It can remember durable preferences. It can follow project instructions. It can operate inside a sandbox. It can create diffs. It can ask for approval. It can spawn subagents. It can work in the background. It can return when the task is done.

That is a different species of tool.

Codex is important because it makes this visible.

Yes, it begins in software. Of course it does. Software is the perfect first battlefield. Code is text. Repos are structured. Tests exist. Logs exist. Diffs exist. The whole environment is already legible to machines.

But coding is not the final category.

Coding is the wedge.

Once you understand the pattern, it expands everywhere.

The same harness logic applies to legal research, financial modeling, sales operations, content production, diligence, recruiting, customer support, internal analytics, compliance, procurement, and executive operations.

The agent needs context.

The agent needs tools.

The agent needs permissions.

The agent needs memory.

The agent needs feedback.

The agent needs evaluation.

The agent needs an environment where work can be attempted, checked, corrected, and shipped.

That is what the harness provides. This is why “prompt engineering” was always too narrow.

The serious skill is ontological architecture.

A prompt is temporary.

A workflow is reusable.

A chat is isolated.

A memory is persistent.

A response is information.

A harnessed agent is true labor.

Memory Changes The Relationship

Memory is one of the most under-appreciated breakthroughs in agents.

People think memory means the system remembers your name, your tone, or a preference. That is the least interesting version.

The real power of memory is operational continuity.

The agent remembers how you work.

It remembers the structure of your projects.

It remembers recurring workflows.

It remembers your standards.

It remembers the failure modes you already corrected.

It remembers the context you should not have to repeat. That changes the relationship from tool to teammate.

A tool resets every time you pick it up. A teammate accumulates context.

That accumulation is the beginning of compounding.

In the old chat world, every session began with context loading. You had to explain the company, the project, the preference, the audience, the constraints, the past decisions, the style, the weird edge cases.

That is friction. Friction kills usage.

Friction keeps AI trapped as an occasional assistant instead of becoming part of the production system.

Memory lowers that friction.

Skills lower it further.

Reusable instructions lower it further.

Plugins and connected tools lower it further.

Eventually, the agent does not just know the task.

It knows the operating environment.

That is when things start to get weird.

Because once agents have memory and tools, work can move from episodic to continuous.

The agent can monitor.

The agent can revisit.

The agent can compare.

The agent can improve the same workflow over time.

The agent can become part of the rhythm of the organization.

That is not a better chatbot. That is a new labor layer.

Wealth Systems

Five Forecasts for the Future of Work

I don’t think people have metabolized what is about to happen to work…

Read more

21 days ago · 2 likes · Matt McDonagh

Long-Running Tasks Change Ambition

The other major unlock is duration.

Short tasks create short thinking.

Long-running tasks create ambition.

When AI only works in single-turn answers, you naturally ask it for things that fit inside a single answer. Summaries. Drafts. Explanations. Lists. Ideas.

Useful, but limited.

When agents can work longer, you ask different questions.

You stop asking for a paragraph and start asking for a project.

You stop asking for an answer and start asking for an investigation.

You stop asking for a suggestion and start asking for a working artifact.

This matters because most valuable work is not a single act of intelligence.

It’s a chain in a sequence:

1. Research.

2. Planning.

3. Execution.

4. Review.

5. Correction.

6. Integration.

7. Shipping.

The old AI interface helped with pieces of that chain.

The new agentic interface starts absorbing the chain itself.

That changes what humans attempt.

If it takes eight hours of human work to explore a path, most people will not explore five paths. They will pick one, maybe two, and live with the uncertainty.

If an agent can explore five paths in parallel, the frontier moves.

You do not need to guess the best approach upfront.

You can run the portfolio.

This is how intelligence becomes abundant.

Not because every answer is perfect. Because the cost of trying collapses.

Cost Performance Changes Behavior

The most important economic fact about AI is not that intelligence gets better.

It is that useful intelligence gets cheaper.

When something is expensive, you conserve it. When something becomes cheap, you waste it productively.

This is what happened with compute. This is what happened with bandwidth. This is what happened with storage. This is what happens with every foundational technology that drops in cost fast enough.

At first, you use it carefully.

Then you use it casually.

Then you redesign the system around the assumption that it is abundant.

Cognitive labor is entering that phase.

The old behavior was scarcity behavior.

Ask one perfect question.

Get one good answer.

Use it carefully.

The new behavior is abundance behavior.

Launch ten attempts.

Make them compete.

Have agents critique each other.

Run the same problem through different frames.

Search the possibility space.

Select the strongest output.

Synthesize the best pieces.

Ship.

This is the core argument.

The winner is not the person who asks AI one better prompt.

The winner is the person who designs a portfolio of attempts, lets agents explore, then applies human judgment to select, synthesize, and ship.

That is the new leverage loop. And it is available to individuals before institutions know what to do with it.

The Bottleneck Moves To Taste

When cognitive labor becomes abundant, output explodes.

That sounds good.

It is also dangerous.

Abundance creates noise.

Agents can produce bad work faster than humans can produce bad work. They can create plausible nonsense, duplicate effort, miss context, overfit to instructions, confidently drift away from the real objective, or flood the zone with artifacts that look finished but are not actually true.

This is why judgment becomes more important, not less.

The naive view says AI reduces the value of human expertise.

The opposite is true at the frontier.

AI reduces the value of raw execution. It increases the value of knowing what good looks like.

Taste becomes a production function.

Verification becomes a managerial skill.

Context becomes capital.

The person who cannot judge outputs will drown in them.

The person who can judge outputs will compound.

This is the paradox of abundant cognitive labor.

The more the machine can produce, the more valuable the human editor becomes. This is why AI will not kill software engineering. The opposite in fact: there is much more software now to maintain and scale!

The more agents can explore, the more valuable the human allocator becomes.

The more drafts appear, the more valuable taste becomes.

The more work gets automated, the more important it is to know what work should exist in the first place.

This is why the future does not belong to passive users.

It belongs to people with agency.

The New Human Capital Stack

The value of raw execution is falling.

The value of direction is rising.

The value of judgment is rising.

The value of taste is rising.

The value of verification is rising.

The value of synthesis is rising.

The value of workflow design is rising.

The value of proprietary context is rising.

The value of coordinating parallel streams of machine labor without losing the plot is rising the most.

That is the new human capital stack.

In the industrial economy, capitalists owned machines and workers operated them. In the knowledge economy, companies owned distribution and workers performed cognitive tasks.

In the agentic economy, high-agency individuals will operate machine labor directly.

Think about the implications of that.

A founder with agents can simulate parts of a company before hiring the company.

A writer with agents can operate like a media team.

An investor with agents can run continuous diligence.

A lawyer with agents can multiply research capacity.

A RevOps leader with agents can connect marketing, sales, customer success, finance, product, and data into one operating loop.

A student with agents can learn through personalized research, tutoring, testing, and project work.

A generalist with agents can become an institution.

That is the real disruption. Not that every job disappears overnight. That the minimum viable team size collapses.

That the ambitious individual gets access to a layer of cognitive labor that used to require a staff.

That small teams can do things that previously required departments.

That departments can do things that previously required whole companies.

That the shape of organization itself begins to change.

The Portfolio Is The New Prompt

The prompt was the first interface. The portfolio is the next one.

This is how serious work will happen.

You define the objective. You decompose the problem. You create multiple workstreams. You give each agent context and constraints.

You let them explore. You force comparison. You review the evidence.

You synthesize.

You ship.

Then you capture the workflow so it can run again.

That last part matters.

If you do not capture the workflow, you are still just chatting.

If you do capture it, you are building infrastructure.

This is where skills, memories, automations, templates, project instructions, and tools become so important. They turn one-off intelligence into repeatable operating leverage.

The first time you run an agentic workflow, you get output.

The tenth time, you get a system.

The hundredth time, you get an advantage.

This is how compounding starts.

Not with a magical prompt. With a repeatable loop.

What To Do Now

The practical mandate is simple.

Stop asking, “How can I use AI more?”

That question is too weak.

Ask better questions:

• What work do I repeat?

• What decisions require too much manual research?

• What workflows depend on context trapped in my head?

• What tasks have clear inputs and outputs?

• What projects would I explore if the cost of trying were 90% lower?

• What workstreams could run in parallel?

• Where do I need a builder, a critic, a researcher, an editor, and an operator working at the same time?

Then build the system.

Write the operating procedure.

Attach the context.

Define the output.

Create the review loop.

Run multiple attempts.

Compare results.

Save what works.

Delete what does not.

Improve the workflow.

Repeat.

This is not about using AI as a novelty. This is about converting your work into agentic infrastructure.

The people who understand this will feel like they have more hours in the day.

Because they will.

Not biologically.

Operationally.

The Top 1% of Codex users (OAI’s agent harness) average 71 hours of agent runtime per day. They are literally getting more hours in the day. And the night. Even when they sleep.

They will run more attempts than everyone else. They will explore more paths. They will learn faster. They will ship more. They will compound context while others are still typing isolated prompts into empty chat windows.

That is the divide.

The Generalist Returns Again

The first revenge of the generalist was access to specialist intelligence.

The second revenge is command over agentic labor.

The generalist was built for this moment.

Broad context matters.

Taste matters.

Curiosity matters.

Pattern recognition matters.

The ability to move between domains matters.

The ability to ask, “What is the actual objective here?” matters.

The ability to see the whole system matters.

The specialist age rewarded depth inside a narrow lane.

The agentic age rewards people who can connect lanes, direct labor across them, and synthesize the result into reality.

This does not mean expertise disappears. It means expertise gets surrounded by leverage.

The best specialists will become terrifying.

The best generalists will become operating systems.

That is the new frontier.

Not human versus AI.

Human plus persistent machine labor.

Human plus memory.

Human plus tools.

Human plus parallel agents.

Human plus the ability to ship in constantly accelerating loops.

Cognitive labor is becoming abundant.

The scarce thing now is knowing what to do with it.

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

It may be agents per megawatt.

That sounds strange if you still think of AI as software. It sounds less strange if you think of AI as labor. And it starts to feel inevitable once you see that inference is becoming an input into almost every form of knowledge work.

For the last century, the richest countries were the ones that could combine people, capital, education, institutions, energy, and coordination into high human productivity. We measured the result as GDP per capita because the human worker was the main unit of economic action. The better the system around that person, the more each person could produce.

That frame is about to get too small.

We are entering a world where a growing share of useful work is performed by agents: model-driven systems with context, tools, permissions, memory, evaluation loops, and the ability to run tasks across time.

Not chatbots. Not autocomplete. Not one-off question answering. Agents.

The unit of work is changing.

A human used to be the smallest practical unit of judgment-bearing labor. Soon, the smallest practical unit will be an agent-hour. Then an agent-minute. Then a swarm of task-specific workers spun up, pointed at a problem, evaluated, merged, and shut down.

When that happens, economic power changes. A country with cheap power, efficient data centers, frontier models, strong orchestration, and the institutions to deploy them will not just have better software. It will have a larger effective workforce.

That workforce will not sleep.

It will not commute.

It will not wait for a meeting invite.

It will be constrained by energy, compute, model quality, data rights, workflow design, and human judgment. But the bottleneck will no longer be only how many educated humans a society can produce. It will be how many useful agents it can run, how cheaply it can run them, and how well it can aim them.

That is a massive shift… a transformation on a societal scale.

We will see inference become a majority input into GDP.

GDP Per Capita Was a Human Era Metric

GDP per capita made sense because people were the scarce productive substrate.

If you wanted more doctors, analysts, or engineers, you trained, hired, educated, or imported more people.

Capital helped. Machines helped. Software helped. But the human was still the point where perception, judgment, communication, and accountability came together.

A factory could multiply a worker. A spreadsheet could multiply an analyst. A search engine could multiply a researcher. SaaS could multiply a manager. But these tools mostly raised the output of a human operator. The person remained in the loop at the center of the task.

Agents invert that relationship.

The human increasingly moves from doing the task to designing the workstream. The operator defines the objective, supplies context, gives tools, creates constraints, selects strategies, evaluates outputs, and decides what ships. The agent does more of the middle.

That middle is enormous.

Most knowledge work is not pure genius. It is reading, summarizing, comparing, formatting, researching, drafting, reconciling, classifying, planning, testing, translating, checking, and following through. It is moving information from one shape to another with enough judgment to avoid obvious failure.

That is exactly the zone agents are entering.

The old economy asked how much output one person could create with a set of tools. The new economy asks how many competent agents one person, one company, or one country can coordinate toward useful ends.

This is why GDP per capita begins to feel incomplete. It tells you how much output is produced per human resident. But it does not tell you how many non-human workers are running inside the system. It does not tell you how much inference capacity a country can direct. It does not tell you whether a small population can operate a vast synthetic workforce.

The denominator is changing.

Work Becomes an Energy Problem

If agents are labor, inference is the fuel.

Training gets the attention because training runs are dramatic. They are large, expensive, and easy to mythologize. But training is the creation of capability. Inference is the use of capability. The more AI moves from demos into work, the more the economic center of gravity moves toward inference.

Every task an agent performs consumes compute.

Compute consumes energy.

Energy flows through data centers.

Data centers become factories for cognitive labor.

This is the part many people still miss. The AI economy is not weightless. It is deeply physical. It needs power generation, grid interconnects, chips, cooling, land, fiber, substations, transformers, supply chains, permitting, and resilience. It needs engineers who understand that the cloud lives somewhere.

The abstract economy is about to become visibly industrial again.

For countries, this changes the strategic map. Energy policy becomes labor policy. Grid capacity becomes workforce capacity. Data center efficiency becomes a national productivity variable. Chip supply becomes not only a technology issue, but a labor market issue.

If your society can support more inference per watt, it can support more agents per megawatt. If it can support more agents per megawatt, it can support more concurrent work. If it can support more work in parallel, it can search more solution space, run more experiments, serve more customers, write more code, monitor more systems, design more products, and compound faster. And faster.

Now imagine a country with the energy, compute, models, and operational stack to run 20 trillion concurrent agents. Or 22 trillion. The exact number matters less than the shape of the thought experiment. A workforce that large, running 24/7, pointed at science, engineering, logistics, education, drug discovery, software, national administration, defense, manufacturing, metamaterials, and business formation, is not a normal productivity improvement.

It’s a discontinuity.

The biggest proliferation of technology in human history may not come from one invention. It may come from the sudden ability to apply persistent cognitive labor to every bottleneck at once.

Not one research team trying one path.

Millions of agent teams trying millions of paths.

Not one analyst producing a report.

Thousands of agents reading the underlying data, generating competing interpretations, testing assumptions, and escalating the five that matter to a human.

This is why agents per gigawatt may become a civilizational metric. It compresses the physical and cognitive reality into one phrase. How much useful work can you extract from energy?

That has always been the question.

AI just makes it explicit.

Agents Outnumbering Humans

This is the last year where a majority of the knowledge workforce is human.

That claim sounds extreme because we are used to counting workers as people with jobs. But the better question is not how many people are employed. The better question is how many workers are doing economically relevant knowledge tasks.

By that measure, 2027 could be the year agents cross the line.

Not because agents will replace every employee. Not because offices disappear. Not because companies suddenly become empty shells. The transition will look stranger than that. Humans will still own goals, relationships, taste, accountability, politics, trust, and many forms of embodied work. But the number of agentic workstreams running across the economy could exceed the number of human knowledge workers much faster than institutions are ready to admit.

A single person may run ten agents in the background.

A small team may run hundreds.

A large enterprise may run millions of short-lived agents across customer support, sales operations, data cleaning, software testing, internal search, finance, legal review, security monitoring, procurement, and analytics.

Most of these agents will not look like employees. They will appear as tasks, runs, workflows, background jobs, assistants, automations, copilots, queues, and systems. That is why the shift will be undercounted.

The economy will add a synthetic labor layer before it knows how to measure it. Traditional employment statistics will still describe the human labor market. GDP will still describe output. But underneath, a new workforce will be forming.

The first sign will not be mass unemployment. The first sign will be output that no longer matches headcount.

Tiny teams will launch products at a speed that used to require departments. Individual operators will sustain a volume of research, writing, analysis, outreach, and coordination that used to require staff. Enterprises will quietly automate the middle layers of work and wonder why their org charts feel less real than their workflow graphs.

The boundary between a tool and a worker will blur. Token economics, coined tokenomics, is one of the most import disciplines of the future because of this.

Wealth Systems

Token Economics Will Drive Everything

Brian Armstrong, CEO of Coinbase made an X post recently containing a blueprint for the next business operating system…

Read more

22 days ago · 2 likes · Matt McDonagh

When a system can receive a goal, gather context, use tools, make intermediate decisions, ask for help, evaluate its own output, retry, and return a result, it is not just software in the old sense. It is a worker-like process. It may be narrow. It may be brittle. It may need supervision. So do many human processes.

The point is not that agents become human. This is not a Pinocchio story. This a production story.

The point is that many tasks never required humanity in the first place. They required adequate cognition, context, and follow-through.

That is what is being industrialized.

The New Production Function

The agent economy has a different production function.

The old formula was roughly people plus capital plus process plus technology.

The new formula is judgment plus context plus tools plus inference plus evaluation. Judgment decides what matters. Context gives the agent access to the relevant world. Tools let it act. Inference performs the cognitive work. Evaluation tells the system whether to keep, retry, escalate, or discard.

Most people focus on the model.

That is understandable. The models are new, they are constantly evolving, but focusing solely on the model is too narrow. The model is the engine. The work happens in the system around the engine.

An agent without memory forgets. An agent without tools talks. An agent without permissions cannot act. An agent without evaluation drifts. An agent without context hallucinates around the edges. An agent without a human operating model becomes noise at scale.

This is why the winners will not simply be the people with access to the best model. They will be the people and institutions that build the best harnesses.

The harness is the agent.

A model in a chat box is potential energy. A model connected to data, tools, workflows, tests, approval gates, and feedback loops is productive energy. That conversion is where the leverage lives.

At the national level, the harness includes power, chips, data centers, institutions, capital markets, and trust. At the company level, it includes clean data, mapped workflows, clear permissions, evaluation suites, and managers who can specify work. At the individual level, it includes taste, tool fluency, and the ability to review more than you personally produce.

The people who win in this world are not passive consumers of AI. They are conductors of work.

They know how to break a vague goal into parallel attempts. They know what can be delegated and what must be judged. They know when to ask for breadth and when to force depth. They know how to compare outputs. They know how to create feedback.

They know how to protect the final mile from slop.

Execution capacity used to be scarce. Now that we are generating at the speed of light, evaluation capacity becomes scarce.

That changes the status of taste.

Taste used to be seen as soft. In the agent economy, taste is an economic bottleneck. If you can generate 100 plans, 100 product concepts, 100 customer segments, 100 investment memos, or 100 design directions, the scarce skill is knowing which three are worth attention and which one deserves resources.

Abundance punishes weak judgment.

When output is cheap, selection matters more.

Leverage, Leverage, Leverage

The same shift happening to countries will happen to individuals, just at a different scale.

Open your phone. Review 10 strategic plans before breakfast. Choose where to deploy 100 hours of deep work. Send agents to research the market, draft the memo, build the prototype, test the copy, reconcile the spreadsheet, summarize the calls, identify the risks, and prepare the next set of decisions.

That is not science fiction. It is the natural endpoint of current behavior.

The best users are already squeezing impossible amounts of output into ordinary days. They are not doing it by typing faster. They are doing it by changing their relationship to work. They are turning tasks into work orders. They are running parallel attempts.

They are treating AI less like a search bar and more like a staff of workers. They have AI planners and AI orchestrators driving AI workers.

You can see the early pattern in people who produce 70 or more hours of output in a day. The point is not that every hour is equal. Some output is shallow. Some needs cleanup. Some is discarded. The point is that the human is no longer personally touching every intermediate step.

The operator creates direction. The agents create surface area. The operator selects, edits, combines, and ships.

That loop can scale.

At 10:1 leverage, one strong person starts to look like a small team.

At 100:1 leverage, a small team starts to look like a company.

At 1000:1 leverage, the old categories break.

The 1000:1 leverage era is not about doing 1000 times more random work. It is about applying a large synthetic workforce to the parts of your life and business where more attempts actually compound. Research. Sales. Product. Investing. Writing. Recruiting. Learning. Code. Operations. Negotiation prep. Market mapping. Scenario planning.

Many people are used to shrinking their goals to fit their available hours. They ask what can I personally get done this week? That question made sense when labor was the binding constraint.

But if agents can execute the middle of the work, the better question is what deserves a fleet?

It forces prioritization. It forces taste. It forces the operator to become clearer about the desired future state. You cannot effectively command agents if you do not know what you want, what good looks like, or what tradeoffs you are willing to accept.

AI does not remove agency from the human. It raises the price of weak agency.

If you have no direction, more agents give you more drift. If you have no taste, more output gives you more confusion. If you have no standards, more speed gives you more mess. But if you have direction, taste, and standards… agents become pure leverage.

That is why this moment is so asymmetric. Passive users will ask for answers. Active operators will assign work. Passive users will wait for perfect agents. Active operators will use imperfect agents inside disciplined workflows.

The future arrives first as a behavior pattern.

The future of work looks very different to the past.

Wealth Systems

Five Forecasts for the Future of Work

I don’t think people have metabolized what is about to happen to work…

Read more

21 days ago · 2 likes · Matt McDonagh

Agents Per Gigawatt

We should start building the language now because the old language will hide the change.

GDP per capita will still matter. Employment will still matter. Wages will still matter. Human welfare is the point, not a side note. But the productive structure beneath those measures is changing.

Inference is becoming labor.

Energy is becoming cognition.

Data centers are becoming workforce infrastructure.

Agents are becoming the new marginal workers of the knowledge economy.

The prediction may be early in its exact timing. Maybe 2027 is the crossing. Maybe it takes a little longer for the measurements to catch up. But the direction is already visible. The human-majority knowledge workforce is not a permanent fact of nature. It’s a historical condition created by the limits of prior technology.

Those limits are changing.

At the macro level, countries will compete on agents per gigawatt.

At the company level, firms will compete on workflows per employee.

At the individual level, operators will compete on leverage per decision.

This is the new labor stack.

The most important question is no longer simply how productive is each person?

It is how much useful work can a person, team, company, or country command?

That answer will define the next economy.

The agent workforce is coming online. It will be measured first in tasks, then in workflows, then in energy, then in GDP.

And eventually the obvious thing will become obvious.

The future of productivity is not just output per person.

It is agents per gigawatt, aimed by people with judgment.

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

Labor intensive operations are massive sinks of capital, time, and human potential.

An architect of automated systems eliminates the bottleneck of human labor, allowing capital to flow directly into perfect, instantaneous execution. You dictate reality through code.

That all means code is the ultimate lever.

And by extension, artificial intelligence is the most powerful lever invented.

It feeds raw energy into all other sciences, technologies, and human efforts. We are standing at the absolute epicenter of a fundamental reorganization of capital, labor, and time. The old paradigms of human productivity are entirely obsolete.

The singularity is already our daily reality.

Systems create leverage. Systems create surface area. Systems create the inevitable outcomes you demand from reality. When you transition from a consumer of software to an architect of autonomous systems, you fundamentally rewrite the laws of physics governing your output.

Agents are the engines of this new world.

Wealth Systems

Five Forecasts for the Future of Work

I don’t think people have metabolized what is about to happen to work…

Read more

21 days ago · 2 likes · Matt McDonagh

You do not need more employees. You do not need more hours in the day. You need a fleet of highly effective autonomous agents executing your strategy flawlessly across every digital domain. The individuals who understand how to build and deploy these digital workers will capture all the economic value of the next decade.

Building them requires absolute precision. Review the 4-part “Introduction to Agentic Engineering” series below to build your baseline. Then we will discuss the 5 keys to building effective agents.

Key 1: Ruthless Contextual Constraints

An agent without a rigidly defined persona is a severe liability. You must lock the model into a hyper specific worldview with immutable rules, distinct boundaries, and explicit goals. Ambiguity breeds hallucination, inefficiency, and catastrophic system failure. When you give a model too much freedom, it will invariably drift from the core objective and waste computational resources.

Precision is the only acceptable standard.

How do you achieve this?

We define the role. We define the constraints. We define the exact format of the desired output. When you engineer the prompt architecture, you are literally programming the neurobiology of your digital worker.

Weak instructions guarantee weak results.

A high agency system requires absolute clarity to operate autonomously. You must strip away all unnecessary context, eliminate conflicting directives, and provide a singular focus. The architecture must reject irrelevant inputs, focus entirely on the core objective, and execute without hesitation. The agent must exist entirely for the specific task it was born to solve.

Constrain the mind to maximize the impact.

You architect the system prompt to be an unbreakable contract. The agent must internalize its identity, recognize its limitations, and operate strictly within the provided framework. If it deviates from the contract, the entire workflow falls apart in unpredictable ways. The foundation of agentic behavior is an ironclad definition of self.

Identity drives behavior.

Engineering this context requires a deep understanding of latent space manipulation. You are shaping the probability distribution of the model to eliminate useless branches of logic. You are forcing the cognitive engine down a narrow corridor of high value execution. You are building walls around the thought process to ensure the output hits the target every single time.

Constraints breed undeniable competence.

You must view the system prompt as the foundational constitution of your digital entity. Every single word carries weight, every instruction shapes the neural pathways, and every exclusion defines the boundary of the agent’s reality.

A poorly drafted prompt leaves massive vulnerabilities in the execution logic, allowing the agent to wander into useless tangents.

You are defining the physics of the agent’s existence. This is almost as important as the next key!

Key 2: Interoperable Tooling and Action Spaces

Read more

It drives raw, unadulterated energy into all other sciences, technologies, and industrial efforts. We are witnessing the deployment of an intellectual engine that alters the fundamental physics of work. Systems create leverage and surface area you can use to drive massive, outsized outcomes.

This is the new reality of leverage.

You must build systems to harness this raw energy. Architectures that capture the explosive growth of machine intelligence.

You must engineer pipelines that convert computational cycles into tangible reality. The current models exhibit extraordinary competence in producing content, code, and structural frameworks at zero marginal cost.

They generate the world.

That said, a fundamental gap remains in the architecture of machine intelligence. The models are rapidly advancing in complex reasoning, logic processing, and algorithmic design. They synthesize complex variables into coherent outputs faster than any biological brain. But they lack the aesthetic, cultural, and contextual compass we define as “taste”.

Taste is the ultimate moat. Taste is the culmination of lived experience, cultural nuance, and emotional resonance. The algorithms calculate the optimal path, but they cannot feel the pulse of a market. They output a thousand software designs, but they cannot recognize the singular masterpiece that resonates with the human soul.

The machine provides the menu.

You make the choice.

The Mechanics of Permutations

The true power of the machine lies in its ability to flood the zone with options.

Don’t outsource your brain to AI. You must use AI to generate variations, mutations, and permutations.

When you confront a problem, you no longer rely on a single human spark of inspiration. You force the model to create ten, fifty, or one hundred distinct approaches to the exact same objective.

Volume creates its own quality.

By generating variations, you explore the immediate boundaries of the core idea. By forcing mutations, you introduce calculated errors and novel structures into the standard paradigm. By demanding permutations, you reorder the variables into entirely new operational models.

The human mind tires after the third iteration. The machine runs until you cut the power.

Iteration is now virtually free.

Consider the architecture of a complex data pipeline. A human data engineer defaults to the familiar patterns they learned over the last decade. They build the same extraction, transformation, and loading sequences they always build. The AI acts differently. It generates a dozen distinct schemas based on pure optimization algorithms.

The machine breaks the bias of habit.

First you command the AI to produce an architecture optimized strictly for latency.

Then command it to produce an architecture optimized strictly for cost reduction.

Then command it to produce a design prioritizing fault tolerance above all else.

The system hands you a comprehensive array of blueprints.

You select the weapon.

This principle applies equally to investment banking and capital allocation. You do not build a single financial model. You instruct the intelligence to generate many conceivable permutations of the deal structure. You model the catastrophic downside, the asymmetrical upside, and the stagnant middle ground simultaneously.

You map the entire territory of risk.

Expanding the Horizon of Possibility

Linear thinking produces linear results. You must use AI to think laterally. The models are trained on the entirety of human knowledge, allowing them to draw connections across entirely unrelated disciplines. They map the architecture of biology onto the structures of financial markets. They apply the principles of fluid dynamics to supply chain logistics.

They bridge the impossible gaps.

When you task an AI to solve a problem, you explicitly command it to pull frameworks from outside your industry. You ask it to approach a software engineering bottleneck with the mindset of an urban planner. You instruct it to analyze an investment thesis through the lens of evolutionary biology. The machine easily navigates these disparate domains to surface completely novel solutions.

Innovation requires this synthetic friction.

Use AI to break your rigid mental frameworks.

Use AI to shatter industry consensus.

Use AI to discover the hidden variables driving the outcome. The machine does not respect the artificial boundaries humans place between physics, economics, and art. It views all data as a unified field of information waiting to be connected.

AI sees the universal patterns. It doesn’t have as many of the heuristic biases that come built into our brains, either.

The Ultimate Adversary

Weak ideas survive in a vacuum. You must use AI to red team your strategies and come up with a comprehensive list of things to improve. The machine has no ego to protect and no feelings to hurt. It savagely deconstructs your business model, your code base, and your investment thesis.

It is the perfect, unyielding critic.

You feed your complete plan into the model and command it to find the fatal flaws. You tell it to adopt the persona of your most aggressive competitor, a skeptical regulator, or an impatient customer. The AI immediately highlights vulnerabilities, edge cases, and systemic risks you failed to consider. It provides an objective diagnostic report of your structural weaknesses.

Destruction paves the way for optimization.

In software development, this adversarial process is mandatory. You write the initial logic and immediately deploy the AI to attack the code. It probes for injection vulnerabilities, memory leaks, and inefficient queries. It generates malicious payloads designed to break your specific architecture.

The machine hardens the shield.

In strategic planning, the red team protocol prevents catastrophic failure. You outline your go to market strategy and demand the AI formulate a counter strategy that destroys your business. The model identifies your reliance on a single distribution channel. It highlights the fragility of your supply chain. It calculates the exact capital required for a competitor to price you out of the market.

You fix the cracks before the flood arrives.

The Architecture of Autonomous Loops

Isolated tasks produce isolated gains. Consider using AI to lock these processes together in continuous, self reinforcing loops. You wire the generation engine to the lateral thinking module. You feed the output directly into the red team adversary.

These systems can run autonomously.

The generator creates the permutations. The lateral thinker injects the novel frameworks. The red team tears the concepts apart and dictates the necessary improvements. The refined parameters feed directly back into the generator to start the cycle anew. This creates a high speed flywheel of continuous intellectual evolution.

Speed is the ultimate weapon.

You architect these loops using basic programmatic logic. You write scripts that trigger the generation phase upon the ingestion of new data. You pipe the raw outputs into the adversarial models using automated API calls. The system runs in the background while you sleep, constantly refining and optimizing the core thesis.

The loop compounds intelligence.

Imagine a trading algorithm locked in this architecture. The generator creates thousands of potential trading signals. The lateral module applies sentiment analysis from obscure geopolitical data sources. The red team model simulates historical market crashes to destroy the weak signals. The surviving signals execute automatically in the market.

This is the physics of infinite leverage.

The Supremacy of Human Taste

The loops spin. The generation multiplies. The options expand into infinity. But keep yourself in the loop and make decisions using a very wide and deep menu provided by AI. The machine builds the labyrinth, but you walk the path.

You are the sovereign arbiter.

You (using AI) review the thousands of generated mutations. You filter the lateral connections. You evaluate the red team vulnerabilities. You apply your cultivated taste to select the single exact configuration that aligns with the market reality. The AI does the heavy lifting, the infinite sorting, and the logical derivation.

You apply the human spirit and taste filter.

Taste is the ability to recognize the resonant frequency of an idea. It is the instinct that knows when a product feels right, when a strategy aligns with the cultural moment, and when an investment holds asymmetrical upside. The machine cannot quantify this instinct. It provides you with the most expansive menu in human history.

You point and execute.

A pure data engineer looks at the numbers and chooses the highest value. A high agency architect looks at the menu and applies context. They know that the mathematically optimal user interface might feel alien to the actual customer. They know the perfectly optimized financial structure might alienate the exact founders they want to back.

Taste supersedes pure computation.

The future belongs to the operators who merge these two domains. The individuals who rely purely on human effort will be crushed by the sheer volume of machine output. The individuals who rely entirely on the machine will produce sterile, uninspired garbage. The victors use the machine to generate the universe of possibilities and use their taste to collapse the wave function.

The Blueprint for Execution

This methodology defines the future of all high agency operations. The individuals who master this dynamic command unprecedented power, influence, and capital. They treat AI not as a tool, but as a boundless cognitive utility. They build empires using the sheer force of computational leverage.

The world belongs to the architect.

You build the system. You define the parameters. You set the loops in motion. The machine floods your dashboard with refined, stress tested, and laterally optimized options. You exercise your taste, make the definitive choice, and drive the outcome into reality.

Leverage is absolute in the singularity.

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

It’s massive not because it predicts the future.

Because it shows the future already forming inside the logs of the most advanced AI software in the world, used daily by millions.

The paper, The Shift to Agentic AI: Evidence from Codex, studies how people are using Codex across individual users, organizational users, and OpenAI workers. The findings are not subtle. They show the exact moment AI stops being a chatbot and starts becoming a labor system.

This is the transition from asking to delegating.

This is the beginning of the agentic economy.

The most important number in the paper is not that active Codex users grew more than fivefold in the first half of 2026, although that alone is extraordinary. The important number is that among OpenAI workers, Codex now accounts for 99.8% of output tokens across Codex and ChatGPT. Organizational users are at 63.3%. Individual users are at 16.5%.

The frontier has already moved.

At OpenAI, the default interface for work is no longer conversation. It is delegation. The employee does not ask a model to explain a concept. The employee assigns a task, lets the agent inspect files, execute commands, modify artifacts, and return completed work.

That is an entirely different economic object.

A chatbot is a faster search bar. An agent is a junior worker with tools.

The old interface was question and answer. The new interface is command and execution. That distinction sounds small until you map it across every knowledge worker in the economy.

Then it becomes civilization-scale.

Software Is the First Battlefield

Codex begins in software because software is the perfect initial substrate for agentic AI.

Code is digital. Code is modular. Code can be tested. Code has clear artifacts. Code has logs, diffs, compilers, tests, repositories, issues, and deployment pipelines. The entire software production system is already machine-readable.

That means software is the first industry where cognitive labor can be fully wrapped in an agentic execution loop.

But the paper makes clear this is not staying inside software.

Codex users are already using it for documents, spreadsheets, memos, data analysis, research, collaboration, communication, planning, recruiting, sales, product work, and legal workflows. The paper repeatedly shows that the deepest adoption expands beyond the original developer base.

This matters.

The normal public narrative says coding agents are for engineers. That is wrong. Coding agents are the first visible form of a broader work agent. The developer is just the first professional whose daily labor is already close enough to executable text that the machine can absorb the workflow.

The same pattern will move outward.

First the agent writes code.

Then it maintains systems.

Then it reads company documents.

Then it drafts reports.

Then it updates spreadsheets.

Then it coordinates across Slack, email, CRM, calendar, data warehouse, and internal tools.

Then the human is no longer doing the work directly.

The human is directing the system that does the work.

This is why the paper’s distinction between conversational AI and agentic AI is so important. Conversational AI produces responses. Agentic AI produces outcomes.

Responses are information.

Outcomes are labor.

The Complexity Curve Is Moving Up

The most powerful section of the paper is about task complexity.

In December 2025, 35.4% of active individual Codex users sent at least one prompt estimated to require more than one hour of experienced human work. By May 2026, that number reached 70.2%.

Even more important: the share of users sending at least one request estimated to require more than eight hours of experienced human work rose from 2.1% to 25.6%.

Read that again.

A quarter of sampled individual Codex users were already handing off tasks that would take an experienced human more than a full workday.

This is not autocomplete.

This is not a productivity trick.

This is humans learning how to package larger blocks of work into machine-executable assignments.

The prompt is becoming the work order. The thread is becoming the workspace. The agent is becoming the production unit.

The paper also finds that the most complex requests tend to happen at the beginning of threads. That makes perfect sense. The human starts by delegating the broad mission. Then the follow-up turns become supervision, correction, refinement, and integration.

That is exactly how managers work with teams.

The initial instruction defines the objective.

The later interaction manages execution.

The human role is shifting up the abstraction stack.

The New Managerial Class

The most important worker in the agentic economy is not the person who knows the most facts.

It is the person who can design, delegate, verify, and integrate machine labor at scale.

The paper’s concurrency data makes this obvious.

Among individual and organizational users, most people are still using Codex in a relatively linear way. Roughly two-thirds of organizational and individual users did not run concurrent turns during the measured week.

But OpenAI workers are already operating differently.

Only 10.7% of OpenAI users ran a sole workflow at any one time. Nearly 28.6% managed five or more concurrent agents at some point during the measured period.

That is the new labor model.

One human. Multiple agents. Parallel execution. Continuous review.

This is not “using AI.”

This is managing an artificial workforce.

The highest-intensity users are already living in that world. The paper shows that the median OpenAI employee had Codex turns running for 2.5 hours on June 11, 2026. But at the 99th percentile, OpenAI employees ran about 71 hours of agent turns within the average day.

Seventy-one hours of work in one calendar day.

That is only possible when work becomes parallelized through autonomous execution.

A human cannot work 71 hours in a day. A human can manage systems that do.

That is the entire economic transition.

Skills Are the New Operating Procedures

The paper’s section on skills and plugins may be the most underappreciated part.

In Codex, skills allow users to encode reusable instructions, workflows, references, scripts, and procedural context. Plugins package capabilities and integrations. Together, they turn ad hoc prompting into repeatable production infrastructure.

That is the leap.

A prompt is temporary.

A skill is institutional memory.

A plugin is distribution.

The paper finds that skill use rose from 5.4% of active Codex users on March 1, 2026 to 26.6% on June 11, 2026. Among individual users, 25.7% invoked at least one skill in the measured week. Among organizational users, 30.4% did. Inside OpenAI, skill use was nearly universal at 96.2%.

This is exactly what should happen.

At first, people use agents manually. They type instructions over and over again. They paste context. They repeat preferences. They correct the same failure modes. They treat the agent like a clever external contractor.

Then the serious users systematize.

They write the operating procedure.

They attach the reference files.

They define the review loop.

They standardize the workflow.

They turn repeated human judgment into reusable machine context.

That is where leverage compounds.

The agent itself is powerful. But the agent connected to persistent procedural memory is far more powerful. The organization that captures its workflows into reusable skills will accelerate. The organization that leaves everything inside scattered chats will drown in its own friction.

This is why the next competitive moat is not just model access.

Everyone will get model access.

The moat is workflow architecture.

The moat is proprietary data.

The moat is captured context.

The moat is knowing how your organization actually works and encoding that into systems agents can execute.

Not Created Equal

The authors are appropriately careful. They note that OpenAI is not a normal organization. Workers there are closer to the frontier, usage is cheap at the margin, training and informal knowledge sharing are common, and the culture is already oriented around these tools.

That caveat is correct.

It is also the entire point.

OpenAI is not just the average firm. OpenAI is the preview environment.

What happens inside OpenAI in 2026 happens inside aggressive technology companies next. Then financial firms. Then professional services. Then media. Then logistics. Then healthcare administration. Then government operations. Then education.

The delay is not capability.

The delay is organizational digestion.

Most companies are still structured around human bottlenecks. Meetings. Approvals. Hand-offs. Status updates. Permission layers. Fragile processes hidden inside people’s heads. These systems were designed for a world where labor was scarce, communication was slow, and execution required humans moving one task at a time.

That world is ending.

The paper shows that when friction drops, work reorganizes around agents very quickly. At OpenAI, Codex became dominant across functions, not just engineering. Legal, recruiting, research, product, communication, and data workflows all moved toward agentic execution.

This is the pattern every serious organization should study.

The question is not whether your employees will use AI.

The question is whether your company can restructure work fast enough to absorb agentic labor.

Human Capital Is Being Repriced

The value of raw execution is falling.

The value of judgment is rising.

The value of system design is rising.

The value of verification is rising.

The value of taste is rising.

The value of proprietary context is rising.

The value of being able to coordinate ten parallel streams of machine work without losing the plot is rising dramatically.

This is the new human capital stack.

In the old economy, workers were paid for performing tasks. In the agentic economy, workers are paid for defining objectives, designing systems, supplying context, judging outputs, and integrating results into reality.

That sounds abstract. It isn’t.

A lawyer who can supervise five legal research agents, review their work, synthesize the answer, and produce a client-ready memo will outperform the lawyer still manually searching documents.

A founder who can deploy agents across product, sales, research, support, finance, and operations will outperform a legacy team waiting for weekly meetings.

An investor who can run continuous diligence agents across filings, technical documents, market data, customer signals, and founder history will outperform the analyst still building static spreadsheets.

A writer who can operate research, editing, distribution, image, and audience-analysis agents will outperform the writer staring at a blank page.

The individual systems architect becomes a company.

The company that fails to become a system becomes obsolete.

What To Do Now

The practical mandate is straightforward.

1. Audit every workflow you touch.

2. Find the repeated tasks.

3. Find the tasks with clear inputs and outputs.

4. Find the tasks where context is scattered but knowable.

5. Find the tasks that require data collection, transformation, drafting, comparison, review, or coordination.

Then turn those workflows into agentic systems.

Do not merely “use AI more.” That is vague and weak.

Build the loop. Write the instructions. Attach the references. Capture the data. Create review checkpoints. Measure output. Improve the workflow.

Repeat until the system becomes faster than the human process it replaced.

This is how you compound.

The people who win will not be the people who occasionally ask ChatGPT for advice. The people who win will be the people who convert their daily work into repeatable agentic infrastructure.

The paper gives us the empirical map.

Agentic adoption starts unevenly.

Technical workers move first.

Non-technical workers follow.

Task complexity rises.

Concurrency rises.

Skill use rises.

Output explodes.

The human moves from operator to orchestrator.

That is path of the singularity.

The Frontier Has Already Crossed

The shift from conversational AI to agentic AI is not a product update.

It is a labor-market phase change.

The chatbot era taught humans to ask better questions. The agent era teaches humans to assign better work.

That is a much bigger transition.

OpenAI’s Codex paper shows the early shape of this world with data instead of speculation. The frontier users are not just chatting more. They are delegating larger tasks, running agents in parallel, reusing codified workflows, and reorganizing their own effort around supervision and integration.

This is how the next economy gets built.

Not by replacing every human overnight.

By turning every high-agency human into the manager of a growing machine workforce.

The leverage curve is bending upward.

The only serious response is to build systems that bend with it!

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

Some of you will remember the piece I wrote about DeepSeek. Naval retweeted it, that got me invited onto a bunch of podcasts and speaking engagements, suddenly I became “the AI guy” and (forgive the cheese) it changed my life.

And here we are again.

GLM-5.2 just came through the side door of the AI industry and kicked the whole building sideways.

Not because it is the undisputed best model in the world.

It isn’t.

Not because it ends OpenAI, Anthropic, or Google.

It doesn’t.

But because it changes the question.

The question is no longer: “Can an open Chinese model catch up to the American frontier?”

The question is now: “How much premium can the closed frontier labs keep charging once open models are this good, this cheap, and this deployable?”

Please read that again.

Because this is the part the market has not fully digested.

GLM-5.2 is not just another benchmark-chasing model release. It is a pressure event. It lands right in the middle of the OpenAI and Anthropic IPO narrative, right as public markets are being asked to underwrite trillion-dollar AI companies on the assumption that frontier intelligence remains scarce, closed, expensive, and defensible.

Then Z.ai shows up with a model that has a 1M-token context window, serious long-horizon coding ability, MIT-licensed open weights, local deployment options, and API output pricing around $4.40 per million tokens.

That is the wrench.

Maybe not a fatal wrench. But definitely a wrench.

The whole valuation story for the big Western AI labs depends on a simple belief: that the best intelligence will remain locked behind proprietary APIs and expensive subscriptions, and that enterprises will have no choice but to pay rent to the model gods.

GLM-5.2 attacks that belief directly.

It says: what if the frontier is not a castle?

What if it is a floodplain?

Z.ai’s own positioning is very clear. GLM-5.2 is built for long-horizon tasks. Not cute chatbot tasks. Not “write me a limerick about SaaS pricing” tasks. Real agentic work: codebases, multi-step engineering, long debugging loops, research reproduction, tool use, sustained execution.

That matters because coding agents are the first place where LLMs stop being toys and start becoming labor.

And GLM-5.2 is aimed directly at that market.

The model extends context from 200K to 1M tokens. But the more important claim is not “it can fit a million tokens.” Lots of people can slap a huge context window on a model and watch performance decay into soup.

The claim is that this is a usable million tokens.

That means a model can absorb the shape of a real software project: the architecture, the file boundaries, the API contracts, the weird historical decisions, the dependency constraints, the tests, the style, the hidden landmines, the things every senior engineer knows after three months and every AI agent usually forgets after twenty minutes.

That is not just “more memory.”

That is continuity.

And continuity is where software agents become dangerous.

A bad coding model can generate snippets.

A good coding model can solve issues.

A great coding model can hold a system in its head long enough to make coherent changes across time.

That is the ballgame.

This is why the benchmarks matter, even if we should never worship them. Z.ai claims GLM-5.2 is the top open-source model across several long-horizon coding benchmarks. On FrontierSWE, it trails Claude Opus 4.8 by about 1% while edging out GPT-5.5. On PostTrainBench, it ranks behind Opus 4.8 but ahead of GPT-5.5 and Opus 4.7. On Terminal-Bench 2.1, it posts an 81.0 versus GLM-5.1’s 63.5.

Again, benchmarks are not reality.

But they are not nothing.

They are smoke. And in AI, smoke usually means the fire is already spreading.

The real shock is the price-performance curve.

A model in the general neighborhood of closed frontier coding models, available for roughly $4.40 per million output tokens, with cached input pricing far below standard input, and open weights you can run yourself if you have the hardware.

This is not just cheap. This is strategically cheap.

This is “why exactly are we paying the frontier tax?” cheap.

This is the part that gets uncomfortable for OpenAI and Anthropic.

Their IPO stories need scarcity. They need the market to believe that intelligence is capital-intensive, yes, but also defensible. They need investors to believe the billions poured into compute create a moat that converts into pricing power. They need “we have the best model” to become “we have the best business.”

GLM-5.2 does not destroy that argument.

But it damages it.

Because every time an open model gets close enough, the premium model companies have to explain why “better” is worth 5x, 10x, or 20x the price.

Sometimes it will be.

For mission-critical tasks, enterprises will still pay for reliability, support, indemnity, governance, safety, integrations, procurement comfort, data controls, and brand trust.

But not always.

And “not always” is where valuations go to get humbled.

If you are a startup burning millions per year on inference, you do not need GLM-5.2 to beat Claude or GPT on every dimension. You need it to be good enough on enough workloads that your unit economics stop bleeding.

If you are an enterprise with sensitive code, you do not need the model to be the universal oracle. You need an option you can host, inspect, constrain, fine-tune, and govern.

If you are a developer using agents all day, you do not need religious loyalty to a logo. You need the model that gets the work done without turning your token bill into a second payroll.

That is the opening.

And it is wide.

This also quietly ruins the vibe around Gemini 3.5 Pro.

Google had its moment lined up. Gemini 3.5 Flash was pitched as frontier intelligence with action, strong agentic coding, long-horizon execution, and speed. Google said 3.5 Pro was coming next. The narrative was supposed to be: Google is back at the frontier, and Gemini is now the model family for agents.

Then GLM-5.2 appears with open weights, 1M context, serious coding benchmarks, and pricing that makes every closed model launch feel a little heavy.

That does not mean Gemini 3.5 Pro will be bad.

It may be excellent. In fact, I would be surprised if wasn’t. Google has absurd infrastructure, elite research talent, distribution everywhere, and a giant surface area across Search, Workspace, Android, Cloud, and everything else. Underestimate Google at your own risk.

But model launches are partly about narrative.

And GLM-5.2 stole oxygen.

It made “frontier agentic model” feel less like a sacred object and more like a category.

That is a huge psychological shift.

The Z.ai technical story is also not trivial. They are not just saying “we trained a big model and it got good.” They are talking about architectural efficiency. IndexShare reuses the same indexer across sparse attention layers and reduces long-context computational cost. They improved multi-token prediction for speculative decoding and increased acceptance length. They are explicitly optimizing the machinery required to make 1M-token work practical.

This is the deeper theme.

The frontier is not just about scale anymore.

It is about efficiency of intelligence.

Who can get the most capability per dollar, per watt, per GPU, per unit of latency, per developer hour?

This is where China has been terrifyingly strong.

DeepSeek showed the world that reasoning could be produced more efficiently than people assumed. GLM-5.2 continues the same pattern in the coding-agent world.

The uncomfortable American lesson is that constraints create invention.

If you have unlimited capital, unlimited GPU access, unlimited pricing power, and a customer base trained to pay premium rates, you can become lazy in ways that are invisible until someone hungrier ships around you.

China’s labs have been forced to optimize. Sanctions, compute limits, and market pressure created a different evolutionary environment. The result is not always the best model in absolute terms. But it is often the best model for the price.

And markets love price-performance.

They always have.

China = Copiers or Innovators?

Now, let’s take the countercase seriously.

Because there is one.

The harshest version goes like this: Chinese models are mostly distills of Western frontier models. They are downstream beneficiaries of OpenAI, Anthropic, and Google doing the expensive first-principles research. They are not creating the frontier at all. In fact they are just compressing it. Progress would stall if these labs did not have armies of VPN accounts hitting Western APIs from non-Chinese IPs, extracting behavior, generating synthetic data, and laundering proprietary intelligence into “open” models.

That argument is not crazy.

In fact, it is almost certainly true, in part.

Distillation is everywhere. Synthetic data is everywhere. Model outputs train other models. The whole field is eating itself recursively.

And yes, the American frontier labs may be doing the most expensive trailblazing. They discover the capability, absorb the failures, pay the compute tax, build the scaffolding, run the safety work, create the product category, and then others imitate the behavior at lower cost.

That is a real concern.

If every cheap open model is downstream of closed frontier labs, then the open ecosystem may be more dependent on the closed labs than it wants to admit.

The “Chinese models are just distills” critique is really an argument about originality, sustainability, and fairness.

Originality: did the model learn fundamental capability from its own training process, or did it learn to mimic the behavior of models that were much more expensive to create?

Sustainability: if Western labs stopped advancing, would these models keep improving or plateau?

Fairness: is this competitive innovation, or is it industrial-scale free-riding?

Those questions matter.

But here is the problem for the countercase: customers do not pay for metaphysics. They pay for results.

If a model solves the task, integrates into the workflow, runs locally, and costs a fraction of the alternative, the buyer does not usually care whether the capability came from pristine original research, clever distillation, open papers, synthetic data, reinforcement learning, or some blurry mixture of all of the above.

The market asks: does it work?

Then: how much does it cost?

Then: can I trust it?

The distillation argument may be morally and strategically important. It may influence export controls, lawsuits, procurement rules, and national security policy. It may absolutely shape how governments respond.

But it does not erase the competitive effect.

A cheaper substitute does not become less disruptive because its origin story is messy.

If anything, that makes the situation more destabilizing.

Because the American labs may be funding the frontier research that commoditizes their own products.

Loops and Curves

Spend $100 billion pushing the frontier.

Watch someone else learn from the exhaust.

Compete against their cheaper model.

Lower your prices.

Raise more money.

Repeat.

That is a brutal loop.

This is why GLM-5.2 matters beyond the model itself.

It points toward a world where frontier capability diffuses faster than frontier economics can stabilize.

The capability curve goes up. The cost curve goes down.

The moat duration shrinks.

That is incredible for builders.. and terrifying for anyone underwriting monopoly pricing.

I still think closed labs have advantages.

They will have the best multimodal systems. They will own premium consumer products. They will have enterprise trust. They will have the deepest research benches. They will build better safety layers, better tool ecosystems, better integrations, better memory systems, better orchestration, better evals, and better support.

Also, open models are not magic. Local deployment is only “free” after you buy or rent serious hardware. A 1M-token MoE model is not casually running. Operationalizing open weights takes engineering skill. Serving long context at scale is hard. Security is hard. Reliability is hard. Fine-tuning can make models worse. Quantization can change behavior. Enterprise support matters.

So no, this is not “OpenAI is dead.”

That is lazy.

The real story is subtler and much more important.

OpenAI, Anthropic, and Google are not being killed by GLM-5.2.

They are being repriced by it.

Their products may still be better.

But their scarcity premium is under attack.

And once scarcity premium compresses, everything changes: margins, growth assumptions, IPO multiples, enterprise negotiations, product bundling, compute strategy, and the speed at which model intelligence becomes a commodity input.

That last phrase is the one to watch.

Commodity intelligence.

Not dumb intelligence.

Not weak intelligence.

Commodity intelligence that is extremely capable, widely available, locally runnable, and cheap enough to disappear into every workflow.

That is a different civilization.

Because when intelligence gets cheap, people stop rationing it.

They put it everywhere.

They run agents against every repo, every spreadsheet, every compliance process, every sales motion, every research question, every personal goal, every operational bottleneck.

The world becomes saturated with cognitive labor.

This is what I meant when I wrote about DeepSeek. The important thing was not just “China made a good model.” The important thing was that the recipe for intelligence production was changing.

GLM-5.2 is another turn of that same screw.

DeepSeek proved reasoning could emerge with shocking efficiency.

GLM-5.2 suggests long-horizon agentic work is becoming open, cheap, and deployable.

That is a massive shift.

The future does not belong only to whoever has the biggest model.

It belongs to whoever can turn intelligence into leverage at the lowest sustainable cost.

And that is why this release feels so important.

We are watching the AI industry move from priesthood to power tool.

From “come worship at our API” to “download the weights and build.”

From subscription intelligence to ambient intelligence.

From closed scarcity to competitive abundance.

There will be lawsuits.

There will be export controls.

There will be safety panics.

There will be national security arguments, some very real and some very convenient.

There will be benchmark fights, distillation accusations, pricing wars, and a lot of people pretending they saw all of this coming.

But the direction is getting clear.

The frontier is leaking.

And once intelligence leaks, it does not go back into the bottle.

Thanks for reading Life in the Singularity.

This post is public, so feel free to share it with someone still underwriting closed-model moats like it’s 2024.

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

It made me analyze the physics of his argument. He is entirely correct about the vector. He is wrong about the velocity.

He misunderstands the psychology of the buyer.

The Anatomy of the Agentic Shift

The internet is being aggressively rewired.

We are shifting from applications built for humans to navigate to infrastructure built for machines to command. If your product is a closed walled garden, you are actively bleeding market share. You will lose to competitors offering seamless integration with AI orchestration layers.

The agentic shift is an undeniable reality. APIs are the new primary users of the internet.

It is the ability to bypass the screen. It is the ability to deliver raw utility. It is the ability to connect without friction.

A clunky interface sitting on top of a world-class API beats a gorgeous interface with zero programmatic access. Agents operate on pure return on investment. If a large language model executes a user goal in three seconds via a raw network call, the user never sees your charts. The user never cares about your gradient buttons or your CSS animations. The user only cares that the task is finished.

Infrastructure always wins over eye candy.

You must understand the concept of torque in software. Torque is the force that generates rotation and movement. An API provides infinite torque. It allows an autonomous agent to execute ten thousand operations in the time it takes a human to find their password. A graphical interface provides massive friction.

When you force a human to click through six menus, you are introducing entropy into their workflow.

You are wasting their time.

You are disrespecting their energy.

Is The UI Dead?

We are told the user interface is completely dead because AI agents are about to take over the internet.

I see the wisdom of this thought. I wrote about it here in 2024 actually. But I’ve had more thoughts since:

• Humans still hold the credit cards.

• Algorithms do not sign enterprise contracts.

• Agents do not wire venture debt.

• AI systems don’t yet have agency, despite the name agents.

You still need a visual surface area to sell the vision. You still need an interface to onboard the human and demonstrate the asymmetry of your value.

The dashboard is not dead. The dashboard is simply mutating. Its core purpose is shifting from a place of execution to a place of calibration.

Instead of doing the work, the human will watch the work. The interface becomes the vital governance layer. Humans require a feedback loop to check what the machines actually did. They must correct edge cases. They must manage permissions to prevent total system entropy.

You cannot audit an invisible agent. Try managing an invisible employee.

You cannot trust what you cannot measure.

If an autonomous agent hallucinates and begins deleting production databases, the human operator needs a massive red button on a highly visible dashboard to kill the process.

The modern operator who has stared into the abyss of operational chaos understands that true leverage is not born from blindly trusting a black box to execute critical tasks, but rather from building a transparent, auditable system where human intuition guides the relentless, untiring execution of the machine.

The Psychology of Control

Let us examine the reality of human cognition. Not every workflow belongs to an agent.

There are deep exploratory tasks. There are highly complex strategic decisions. There are creative problems where a human must visually steer the ship.

The human brain processes visual geometry millions of times faster than raw text or data arrays. We need to see the map to find the torque. We need the visual representation to understand the battlefield.

If you strip away all visualization, you strip away human intuition.

Let us return to the psychology of the buyer. The human operator is swimming in a sea of anxiety. They are terrified of making the wrong software purchase. They are terrified of being replaced by the very technology they are deploying.

If you sell them an invisible box of code, they will panic. They need the psychological safety of a dashboard. They need to see the dials. They need to feel like they are still necessary.

The author of the viral take assumes human beings are perfectly rational actors. He assumes we only care about raw efficiency. We are not rational.

We are emotional creatures driven by a primal need for survival and control. The interface provides the illusion of control. The interface provides psychological safety.

The Fallacy of Time

Now let us address the timeline. The idea that non-API-first software will be obliterated in six months is pure hyperbole.

It is engagement bait designed to trigger your anxiety. It ignores the fundamental laws of enterprise physics.

Business-to-business software moves with the speed of a glacier. Procurement cycles take six months just to agree on security terms. SOC 2 compliance audits take a year. Risk aversion is the absolute default setting of the corporate stack.

Legacy lock-in is a gravitational force. Companies do not rip and replace mission-critical infrastructure overnight. They do not tear down the house because a new agentic workflow dropped on social media.

Momentum protects the incumbent. Change requires energy. Most organizations lack the energy to change their own passwords, let alone their entire software architecture.

The future is absolutely API-first.

But the transition will take a decade, and the interface remains the permanent bridge between silicon execution and carbon oversight.

Extreme Ownership in the Machine Age

I know you are exhausted. I understand the visceral burnout of the modern software game.

You are grinding through the chaos trying to predict the future. You feel the stagnation of your current metrics. You are afraid of becoming obsolete.

I validate that fear. The fear is real. But I refuse to let you settle for mediocrity. I refuse to let you act like a victim of technological progress.

Take extreme ownership of your stack. Stop whining about the pace of change. Stop fearing the autonomous agents.

Harness them. Build the endpoints. Demand excellence from your engineering.

Let’s dissect the anatomy of leverage. Leverage is force multiplication. Labor is a terrible form of leverage. Capital is a decent form of leverage. Code is the ultimate form of leverage.

But code hidden behind a graphical interface is capped leverage. It is an engine locked in a cage. An API removes the cage. It allows your code to multiply its force infinitely across the internet. It turns your software into a composable primitive that other machines can string together to build entirely new realities.

If your user fails to achieve their goal, it is not their fault. It is your fault. If they cannot navigate your dashboard, you are the problem. If an AI agent cannot read your documentation or authenticate with your endpoint, you have failed.

You own the friction. You own the entropy. Eliminate it.

Your code must be a pure system for leverage.

Your architecture must be entirely antifragile.

When the agents flood the network, fragile software breaks. Antifragile software scales. Every ping to your server should make your system stronger. Every automated call should increase your market dominance.

You do not write the code. The code writes you.

Your habits form your architecture. Sloppy thinking produces sloppy endpoints. Rigorous philosophy produces rigorous infrastructure. You must treat your software stack the way you treat your mind. Protect it from garbage. Optimize it for clarity. Feed it raw signal.

The Ultimate Calibration

You must build for the machine while selling to the human. This is the ultimate calibration. This is the new alchemy of software.

Do not panic. Do not rush to delete your interface. Repurpose it.

Make your interface a control room. Make it a cockpit for the human to monitor the machines. Give the user absolute clarity.

Give them the power to stop the algorithm. Give them the power to accelerate the algorithm. Control is the ultimate product feature. Peace of mind is the ultimate deliverable.

The market will ruthlessly separate the tourists from the operators. The tourists will build pretty interfaces with no raw utility. The operators will build massive utility engines wrapped in transparent audit layers.

You must choose your path. You are either the engine or you are the friction. You are either the leverage or you are the bottleneck.

Strip away the unnecessary code. Expose your core value directly to the network. Let the models consume your endpoints. Let the agents do the heavy lifting.

But keep the human firmly in the pilot seat.

The world is incredibly noisy. The chaos is accelerating. You must anchor yourself in objective reality.

The reality is machines execute better than we do. The reality is humans strategize better than machines do. Combine the two.

That’s our special role in this magical machine we are building together.

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

I do not buy it.

Orchestration matters. Routing agents, managing tasks, governing execution, and coordinating tools will become part of every serious AI operating system. But that does not make orchestration the moat. In fact, the opposite is more likely. The more important orchestration becomes, the more aggressively foundational model companies, cloud platforms, and enterprise software incumbents will absorb it.

The workflow layer will not disappear. It will become expected infrastructure.

The real moat will form somewhere harder to copy: trusted execution on top of proprietary data, inside high consequence environments, with a human interface that gives leaders confidence to delegate work to machines.

That is where I would look as a builder. That is where I would look as an investor.

My background makes me biased here, but it is a useful bias. I began in investment banking, where the entire game was return on time, leverage, judgment, and information quality. That obsession pulled me into technology. Co-founding a hedge fund to automate financial analysis made the lesson sharper: AI is the physics of value, but data is its logistics. Intelligence without reliable data movement is trapped potential. It can reason, but it cannot operate at scale.

That is still the core truth.

Today I build, invest, and scale with AI. I work as a Data Engineer and Agentic Engineer, creating AI agent operating systems and related solutions for Fortune 500s, family offices, professional services firms, and fast growing startups. The mission is simple: increase return on time by combining technology with strategy.

From that seat, the current market debate looks incomplete. Everyone is watching model capability expand. Fewer people are watching the engine underneath: the data supply chain feeding the AI, the trust architecture around its actions, and the human surface where accountability lives.

That is where the durable companies will be built.

The first mistake is assuming orchestration stays independent.

Every major model company wants orchestration.

They do not want to be a raw intelligence API sitting underneath someone else’s workflow layer.

They want to be the cognitive engine, the planner, the router, the memory layer, the tool caller, and the execution environment.

They want the developer relationship, the enterprise relationship, and the user relationship.

That should be obvious.

If a startup says its moat is that it can break a task into subtasks, call tools, route work between agents, and summarize the result, it is standing in the path of the largest companies in technology. OpenAI, Google, Anthropic, Microsoft, Amazon, and Salesforce are not going to leave that surface untouched. They will keep compressing orchestration into the model and the platform.

What is impressive today becomes table stakes tomorrow.

This does not mean orchestration companies are doomed. It means orchestration alone is not enough. A generic agent router is a feature. A generic workflow builder is a feature. A generic agent management layer is a feature. The question is what sits behind it and what sits above it.

Behind it: unique data, context, permissions, business logic, historical decisions, system mappings, and operational memory.

Above it: trust, governance, auditability, liability management, and human control.

Remember that: behind and above it.

That is the actual stack.

The second mistake is believing the old SaaS wedge playbook transfers cleanly into AI.

In SaaS, a narrow workflow could become a beachhead because software was expensive to build, slow to sell, and painful to replace. If you solved a specific workflow well enough, you could expand into adjacent workflows. Over time, the customer embedded you into operations. Integrations accumulated. Training accumulated. Reports accumulated. Permissions accumulated. Switching costs hardened.

That logic still exists, but AI weakens parts of it.

A narrow workflow is easier to copy now. Not always easy, but much easier. The same model APIs, vector databases, document parsers, automation tools, and UI kits are available to everyone. A workflow that once required a product team can now be prototyped by a small team in days.

The gap between idea and imitation has collapsed.

That changes the wedge.

A niche workflow is not automatically strategic real estate. Sometimes it is just a campsite.

If the workflow is low risk, low data depth, low integration depth, and low trust burden, it will get copied, bundled, or absorbed. If the workflow depends mostly on prompting, it is not a company. It is a temporary advantage. If the workflow can be replicated by a model update, it is not a moat. It is a countdown.

The better wedge is not merely narrow. It is painful, data rich, operationally embedded, and trust constrained.

That distinction matters.

A startup should not ask, “Can we automate this workflow?”

That bar is too low.

The better questions are: Does this workflow touch proprietary data? Does it require cross system context? Does it sit inside a regulated or high consequence process? Does it demand audit trails? Does it improve as it learns the customer’s operating model? Does the buyer trust the system more over time? Does implementation create a data and process map that competitors cannot easily reproduce?

That is the difference between an AI tool and an AI operating system.

My work in RevOps, engineering, and investing keeps bringing me back to this point. Revenue engines are not just sequences of tasks. They are living systems made of strategy, data quality, incentives, handoffs, customer context, and execution discipline. You cannot drop generic AI into that and expect magic. The AI needs clean inputs, trusted permissions, clear goals, feedback loops, and a reliable understanding of the business.

That is data engineering. That is agentic engineering. That is business architecture.

It is also why data remains central.

The argument that AI moats move from data to orchestration sounds elegant, but it overcorrects. In the SaaS era, data gravity mattered because workflows formed around systems of record. In the AI era, data still matters because agents cannot act intelligently without context. They cannot infer what they cannot access. They cannot govern what they cannot see. They cannot optimize what they cannot measure.

AI may be the physics of value, but data is still the logistics.

If the data supply chain is broken, intelligence does not scale.

This is obvious inside real companies.

The problem is rarely “We need a smarter model”…

The problem is usually, “Our customer data is fragmented, our definitions are inconsistent, our permissions are messy, our process lives in people’s heads, and nobody knows which system is true.”

That is not a model problem.

That is an operating problem.

The companies that solve it will matter. They will not merely build chatbots. They will build the connective tissue between enterprise memory and enterprise action. They will make data usable, workflows governable, and agents accountable.

That brings us to the third and most important point: the ultimate moat is trust.

Not vague brand trust. Not a slogan. Operational trust.

Trust that the agent knows what it is allowed to do. Trust that it can explain what it did. Trust that a human can intervene. Trust that sensitive data is handled properly. Trust that the system respects the difference between drafting a recommendation and executing a decision. Trust that when something goes wrong, the organization can trace the event, assign responsibility, and improve the system.

This is where most AI demos fall apart.

The demo looks magical because the cost of failure is invisible. In the real world, failures have owners. A bad revenue forecast changes hiring. A bad compliance decision creates legal exposure. A bad client communication damages a relationship. A bad trade loses money. A bad data merge corrupts the source of truth.

Enterprises do not adopt AI because it is clever. They adopt AI when they believe it can be controlled.

That is why the human interface matters so much.

The winning AI companies will not only automate work. They will design the cockpit where humans supervise work. They will let teams monitor agents, approve actions, inspect reasoning, compare outputs, review exceptions, and tune behavior. They will make delegation feel safe.

This is a higher order product challenge than orchestration.

A routing engine can decide which agent should handle a task. A trust interface decides whether a human is comfortable letting the task happen at all.

That is the real bottleneck.

In high consequence environments, the interface is not cosmetic. It is the control plane. It determines adoption, expansion, and retention. The customer does not just ask, “Can this system do the work?” The customer asks, “Can I bet my business process on this system?”

That is a very different question.

The best AI systems feel less like tools and more like operating environments. They combine data infrastructure, agent coordination, permissions, memory, policy, analytics, and human oversight into one execution layer. Orchestration will be inside that layer, but it will not be the source of defensibility by itself.

Defensibility will come from compound context.

Every customer deployment should make the system smarter about that customer’s world. Not through vague model training claims, but through structured operational learning: how the business defines accounts, how it segments customers, how approvals work, which exceptions matter, which data sources are trusted, which workflows create risk, which actions require escalation, and which outcomes prove value.

That knowledge is hard to copy because it is earned through implementation.

It is also why the best builders will need more than prompt engineering. They will need strategy, systems thinking, data engineering, and code. They will need to understand GTM architecture, business operations, master data management, AI system design, Python, JavaScript, TypeScript, and SQL. They will need to connect boardroom priorities to database realities.

That is the work.

The market is going to punish thin AI products. It will reward systems that sit close to value creation and make organizations meaningfully faster, smarter, and more precise.

For founders, the takeaway is not “do not build workflows.”

Build workflows. But pick the right kind.

Do not chase a workflow because it is easy to demo. Chase one because it reveals a valuable data layer, earns trust in a high consequence process, and gives you permission to expand into the customer’s operating model.

Do not build orchestration as an abstract layer and hope the market comes. Build trusted execution in a painful domain.

Do not assume narrow means defensible.

Narrow is only useful when it is the entrance to depth.

For investors, the filter should be equally direct.

Ask what data advantage compounds. Ask what trust burden the company owns. Ask whether model improvements help the company or replace it. Ask whether the product becomes more valuable as it maps the customer’s business. Ask whether the company can survive the next foundation model release. Ask whether implementation creates durable context or just temporary configuration.

Most AI companies will not have great answers.

The ones that do will be obvious.

They will look less like clever wrappers and more like infrastructure for judgment, execution, and accountability. They will help professionals do higher leverage work. They will increase return on time. They will sit at the intersection of technology and strategy.

That is where I want to build. That is where I want to invest.

I am grateful to work with and invest alongside some of the smartest people on Earth. The shared lesson across those rooms is that leverage is never free. Every new capability creates a new constraint. AI increases the speed of thought and action, but it also increases the importance of data quality, governance, and trust.

So no, I do not think orchestration is the final AI moat.

Orchestration will matter. It will be everywhere. That is precisely why it will be hard to defend on its own.

The enduring moat will be trusted AI execution powered by superior data logistics.

The winners will not simply route agents.

They will make enterprises comfortable handing real work to machines.

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

We built foreign policy around scarcity.

We tolerated trade deficits as if they were gravity.

We treated energy dependence as an unavoidable tax on prosperity.

We sent capital outward, imported vulnerability inward, and called the arrangement “strategic”.

That era is over.

The United States did not negotiate its way out of energy dependency. It engineered its way out. It did not beg hostile producers for mercy. It drilled, fractured, piped, refined, liquefied, transmitted, exported, and optimized. It converted geology into leverage. It converted private risk capital into national power.

It converted a structural weakness into a strategic weapon.

In 2000, the U.S. produced 69.262 quadrillion British thermal units of energy and still ran a net energy import deficit of 24.904 quads.

By 2019, annual energy exports exceeded imports for the first time since the early 1950s, driven by shale oil, natural gas, LNG capacity, and the collapse of crude import dependency.

This was not a policy slogan. It was a system-level reversal.

Energy dominance means something deeper than independence. Independence implies defense. Dominance implies agency. It means the United States is not merely trying to keep the lights on inside its own borders. It is shaping global energy flows, underwriting allied grids, suppressing the power of hostile exporters, and creating a domestic industrial base that can absorb shocks the old America would have imported straight into its bloodstream. True energy power is not autarky. The United States still imports, blends, refines, and trades. But it now does so from optionality, not desperation.

The old world asked: “Where will America get its energy?” The new world asks: “How much of America’s surplus does the world need?”

The answer is increasingly obvious. In 2024, the United States exported roughly 30% of its domestic primary energy production, shipping record volumes into Europe and Asia.

The EIA reported that of roughly 103 quads produced in 2024, about 31 quads went to other countries, with nearly all exports consisting of fossil fuels moving through global markets that now depend on U.S. supply depth. (U.S. Energy Information Administration) That is not a footnote. That is a geopolitical operating system.

The first pillar of America’s energy dominance strategy is hydrocarbon supremacy. This is the foundation. You do not run an industrial civilization on wishes. You run it on dense, dispatchable, transportable energy. Petroleum still powers the transportation arteries of the economy. Natural gas still anchors the electrical grid, heats homes, feeds industry, backs up renewables, and keeps manufacturing alive. The shale revolution turned tight rock into national leverage.

Horizontal drilling and hydraulic fracturing did not just increase production... they changed the bargaining position of the American Empire.

The numbers are wild.

By 2025, U.S. total energy production reached a new record of roughly 107 quads. Dry natural gas production climbed above 39 trillion cubic feet. Crude oil production reached a record 13.6 million barrels per day, with crude alone accounting for 26% of domestic energy production. Natural gas plant liquids reached a record 4 trillion cubic feet, feeding the petrochemical base that turns cheap molecules into high-value industrial output. (U.S. Energy Information Administration) This is what dominance looks like at the physical layer: basins, rigs, crews, pressure pumps, gathering systems, processing plants, pipelines, storage, terminals, and refineries moving in coordinated force.

But production alone is not strategy.

Production without logistics is trapped value.

A barrel that cannot reach a refinery is stranded geology. A molecule of gas without liquefaction capacity is a regional commodity. A watt without transmission is local noise. The second pillar is infrastructure scaling. America’s advantage is not just underground. It is in the machinery that moves energy from rock to refinery, from basin to port, from terminal to allied grid. LNG export terminals along the Gulf Coast turned domestic natural gas into diplomatic force.

Ports, pipelines, storage tanks, and shipping contracts turned abundance into reach.

The refining complex is one of the most under-appreciated weapons in the American arsenal. The United States does not simply produce crude and hope the world buys it. It operates a sophisticated refining machine capable of importing heavy, sour barrels, blending them with light domestic shale output, and exporting higher-value products into global demand. In 2024, refined petroleum product exports reached 11.448 quadrillion BTUs, with Canada and Mexico anchoring a deeply integrated North American energy bloc. This is energy arbitrage at sovereign scale: import strategically, process intelligently, export profitably, and harden the continent’s supply chain.

The third pillar is natural gas as the bridge fuel and industrial accelerant. Natural gas is the load-bearing wall of the modern American grid. It replaced coal because it was cheaper, cleaner, more flexible, and abundant. It enabled combined-cycle generation to scale. It gave renewables a partner. It lowered industrial input costs. It produced natural gas liquids that became feedstock for petrochemicals, plastics, polymers, and specialized fuels.

Natural gas has been the largest source of U.S. domestic energy production since 2011, and the 2025 surge to 39 trillion cubic feet confirmed that this is not a transient boom but an embedded production regime.

This matters because energy dominance is not just about exports. It’s about rebuilding the domestic industrial organism. Cheap, reliable natural gas gives factories a reason to exist here. Cheap feedstocks give chemical producers a reason to expand here. Reliable baseload gives data centers, semiconductor fabs, defense manufacturing, steel, fertilizer, glass, cement, and advanced manufacturing a foundation.

The nation that controls energy costs controls the economics of reshoring. The nation that can power the next industrial stack controls the next strategic cycle.

The fourth pillar is electron dominance: gas, nuclear, renewables, and transmission working as a coordinated grid, not as ideological tribes fighting for purity. An advanced civilization cannot afford religious energy policy. It needs power that is cheap, reliable, scalable, dispatchable, resilient, and politically survivable. Natural gas provides flexibility. Nuclear provides zero-carbon baseload. Renewables provide increasingly large volumes of low-marginal-cost electricity where geography and grid capacity cooperate. In 2024, renewables reached 23% of total U.S. electricity generation, surpassing both nuclear and coal in the generation mix, while nuclear stabilized around 8.165 quads in 2024 and 8.195 quads in 2025.

We are not choosing between molecules and electrons. We are stacking them.

Expect to see a lot more nuclear in the future!

This is the part the ideologues miss. A serious energy strategy does not kneecap hydrocarbons to flatter climate theater, and it does not reject nuclear or renewables to perform nostalgia.

It is smart to compound every advantage. Drill where drilling is rational. Build pipelines where pipelines are needed. Expand LNG where allied demand exists. Preserve and extend nuclear where baseload matters. Deploy solar and wind where they are economically and geographically sensible. Build transmission because trapped electricity is stranded capital. Harden the grid because an electrified economy with a fragile grid is a hostage.

The fifth pillar is efficiency as a weapon. Dominance is not only producing more. It is needing less energy per unit of output. A wasteful empire burns its advantage. A disciplined empire compounds it.

In 2024, U.S. primary energy consumption per real dollar of GDP stood at 4.04 thousand Btu per chained 2017 dollar, evidence that the economy now converts energy into wealth far more efficiently than previous industrial structures. This is not weakness. This is leverage. When production rises while domestic consumption stays structurally contained, the surplus becomes export power.

That surplus is the strategic prize. In 2024, U.S. production hit 103.537 quads while consumption sat at 94.544 quads. In 2025, production climbed again to 106.913 quads while consumption was 96.209 quads, pushing the net export margin to 10.956 quads.

The divergence between production and domestic burn is the machine.

Every efficiency gain at home frees more energy for foreign revenue, allied security, and geopolitical pressure against competitors. Every barrel not required domestically can become an export. Every molecule not burned inefficiently can become leverage.

The sixth pillar is alliance power. Energy exports are not merely commercial flows. They are diplomatic bonds. When Europe reduces dependence on Russian pipeline gas, American LNG becomes more than fuel, it becomes strategic insulation. When Mexico and Canada integrate with U.S. crude, refined products, and natural gas flows, North America becomes a continental energy fortress. When Asian buyers diversify away from fragile chokepoints and hostile suppliers, U.S. molecules become geopolitical insurance. Energy dominance gives America something more useful than rhetoric. It gives America control.

This is why export capacity is not an afterthought. It is grand strategy.

An America that produces only for itself is strong. An America that produces enough to stabilize allies is powerful. An America that can flood markets during cartel manipulation can compress the leverage of hostile producers. An America that can provide LNG, refined products, coal exports where demanded, petrochemicals, and crude at scale turns geology into statecraft.

The seventh pillar is capital discipline. Energy dominance was not produced by slogans. It was produced by capital expenditure, engineering iteration, legal frameworks, mineral rights, private operators, risk tolerance, bankruptcy cycles, efficiency gains, and ruthless learning curves. The shale patch learned to drill faster, complete better, recover more, and survive lower prices. LNG developers learned to turn stranded gas into global contracts. Renewables developers learned to scale manufacturing, installation, and financing. Systems improve when capital is allowed to test, fail, restructure, and redeploy.

This is why the policy objective should be brutally clear: remove artificial bottlenecks while preserving operational standards.

Permit faster.

Build transmission.

Approve pipelines where needed.

Expand export terminals.

Develop more nuclear.

Modernize the grid.

Support storage where it actually improves reliability.

Protect domestic refining capacity.

Accelerate interconnection queues.

Harden physical and cyber infrastructure.

Stop treating energy abundance as an embarrassment. The world is not becoming safer. Industrial power is returning as the core measure of national strength.

The countries that win the next century will not be the countries with the cleanest slogans. They will be the countries with the most reliable power.

AI data centers, autonomous factories, advanced defense systems, desalination, robotics, electrified transport, semiconductor fabs, and resilient cities all require energy density and grid reliability. The next strategic contest will not only be about who has the best algorithms. It will be about who can power them. Intelligence without electricity is a dead asset. Manufacturing without heat is a fantasy. Sovereignty without fuel is theater.

If the United States wants to dominate AI, advanced industry, defense production, and space infrastructure, then energy abundance is not optional. It is the root asset.

The American strategy in one sentence: produce more, waste less, move faster, export intelligently, and harden everything.

This is not an argument for mindless extraction. It is an argument for intelligent abundance. The country should not burn resources stupidly, pollute carelessly, ignore environmental risk, or confuse volume with strategy. But it should also reject the anti-industrial instinct that treats energy scarcity as virtue.

Scarcity does not create morality. Scarcity creates dependence. Dependence creates weakness. Weakness invites coercion.

The cleaner path is not poverty with better branding. The cleaner path is technology, efficiency, nuclear durability, gas reliability, renewable scale, industrial discipline, and relentless infrastructure execution.

America’s energy dominance strategy is ultimately a sovereignty strategy. It gives households price stability. It gives manufacturers confidence. It gives allies alternatives. It gives diplomats leverage. It gives the military operational depth. It gives entrepreneurs cheap inputs. It gives the grid redundancy. It gives the nation options when the world breaks.

The old America imported energy panic. The new America exports energy stability.

Decline is not destiny when a country still has operators, engineers, capital, geology, infrastructure, and will.

The task now is not to celebrate the machine. The task is to expand it.

Drill the basins. Build the pipes. Upgrade the grid. Export the surplus. Defend the terminals. Preserve the refineries. Extend the reactors. Scale the renewables. Train the workforce. Compress the permitting timelines. Protect the cyber layer. Use efficiency not as an excuse for less ambition, but as a weapon that frees more supply for strategic deployment.

Energy is not a sector. Energy is the substrate beneath every sector.

We cannot export intelligence if we import energy.

A nation with abundant, diversified, export-capable energy shapes the world’s operating conditions. That is the position America is in. That is the advantage now on the table.

Now we must use it productively to scale our intelligence machinery, scale robotics and transform into a multi-planetary species.

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

It will belong to the company that knows which model to use, when, why, at what cost, under what constraint, and with what fallback plan.

This sounds less glamorous than frontier intelligence.

It is not.

This is where the leverage comes from.

The amateur stares at the model leaderboard. The operator studies the system. The amateur asks, “Which AI is best?” The architect asks, “Best for what, under which latency requirement, at which margin structure, with which regulatory exposure, and how does the system respond when that provider fails?”

That second question is the entire game.

Models are engines.

The router is the transmission.

Without the transmission, power is wasted. You can own the strongest engine on earth and still destroy the vehicle if every task is forced through the same gear. You do not use a drag-racing engine to idle through a parking lot. You do not use a scooter to haul freight.

You do not fire a missile at a mosquito.

And yet this is how most companies are going to use AI.

They will hardcode one provider. They will route every request through the same model. They will pay frontier prices for commodity work. They will send complex work to models that cannot reason through it. They will tolerate unnecessary latency. They will break during outages. They will expose themselves to policy shocks, rate limits, model sunsets, and regulatory seizures they did not prepare for.

Then they will call AI expensive, unreliable, risky, and overhyped.

No. Their architecture was weak.

The model router is becoming the control plane of applied AI.

And control planes become very valuable.

The End of Model Religion

The first wave of AI adoption was tribal.

People picked a model and defended it like a flag. This one is smarter. That one is safer. This one codes better. That one writes better. This one has the best context window. That one is cheaper. This one has better tools. That one is open source.

This is predictable.

When a technology is new, people form religions around artifacts.

But mature systems do not run on religion.

They run on allocation.

The future is not one model to rule them all. The future is dynamic allocation across intelligence markets. Every request becomes a packet of work. Every packet has a shape. Some require deep reasoning. Some require speed. Some require domain knowledge. Some require tool execution. Some require privacy. Some require cost discipline. Some require multimodal perception. Some require structured output. Some require brute-force generation at scale.

A single model can serve many tasks.

But no single model will be economically, operationally, and strategically optimal for every task.

The routing layer recognizes this.

It turns AI from a tool into a portfolio.

And portfolios need managers.

Reason One: Cost Optimization

The easiest reason is cost.

It is also the one executives will understand first.

Frontier intelligence is expensive because frontier intelligence is scarce. You should absolutely use it when the task deserves it. Planning. Strategy. Legal analysis. Code review. Complex research synthesis. High-stakes decision support. Multi-step reasoning. Evaluation. Final answer review. Anything where hallucination, poor judgment, or shallow reasoning creates downstream damage.

But most work does not require the most powerful model available.

Most work is classification, extraction, transformation, summarization, formatting, routing, tagging, translation, enrichment, search expansion, spreadsheet cleanup, customer support triage, document chunking, metadata generation, basic drafting, and mechanical execution.

Sending all of that to a frontier reasoning model is financial malpractice.

It is like hiring a senior partner to alphabetize files.

The correct architecture is layered.

Use frontier intelligence for the parts of the workflow where judgment matters. Use cheaper models for the parts where volume matters. Use open-source or smaller models for repetitive production. Use specialized models where the domain is narrow. Use the strongest model as planner, evaluator, and escalation path.

This becomes standard.

A system might use a frontier model to decompose a project, assign subtasks, define quality standards, and review the final output. Then it uses cheaper models to execute the bulk work. Another model checks formatting. Another model classifies risk. Another model produces embeddings. Another model handles simple user-facing replies.

The user sees one product.

Underneath, the system runs an intelligence supply chain.

This is margin architecture.

The companies that learn to route will deliver stronger output at lower cost. The companies that do not will either destroy their gross margins or degrade the product to survive.

There is no mystery here.

If intelligence becomes an input cost, routing becomes procurement.

And procurement at scale is war.

Reason Two: Capability Maximization

Cost is only the surface.

The deeper reason is capability.

The “bitter lesson” remains broadly true: general methods powered by scale tend to win over handcrafted specialization. Models will continue improving in the same general direction. They will become more multimodal, more tool-capable, more agentic, more context-aware, and more reliable.

But “generally better” does not mean “identical.”

Differences still matter.

Some models are better at code. Some are better at tool use. Some are better at long-context synthesis. Some are better at math. Some are better at creative language. Some are more obedient to schema. Some are better at refusing dangerous tasks. Some are better at multilingual work. Some are better at particular enterprise workflows. Some are better at extracting clean structure from dirty documents. Some are better at planning. Some are better at critique.

A serious AI product should not pretend these differences do not exist.

It should exploit them.

The routing layer becomes a capability maximizer. It studies the job and selects the best weapon. Not the most famous weapon. Not the newest weapon. Not the one with the loudest benchmark release.

The best weapon for that specific mission.

This is how applied AI products get better without waiting for the next model release.

They become smarter at orchestration.

The router can send coding tasks to the model with the best current coding performance. It can send mathematical verification to a model with stronger formal reasoning. It can send brand-sensitive writing to a model tuned for voice. It can send tool-heavy agent tasks to a model that reliably calls tools instead of narrating about tools. It can send medical, legal, or financial work into stricter review chains with multiple models checking each other.

This is not complexity for its own sake.

This is precision.

A world with many strong models rewards the layer that can compose them.

Reason Three: Latency and Performance Tuning

Users do not care how elegant your architecture is.

They care whether the product feels alive.

Speed matters.

In user-facing applications, latency is not a technical detail. It is part of the product’s soul. Slow products feel stupid even when they are smart. Fast products feel intelligent even before the intelligence fully arrives.

The routing layer protects the experience.

A simple question should not crawl through a heavyweight reasoning model if a smaller model can answer instantly. A button click should not wait behind a deep research task. A customer support response should not take ten seconds because the system is overthinking a password reset.

But the reverse is also true.

A complex strategic query should not be rushed through a cheap model just because the application is trying to feel fast.

The router makes the trade.

It evaluates complexity, urgency, user tier, traffic conditions, context length, required confidence, and whether the task is synchronous or asynchronous. Then it assigns the job.

Simple, real-time interaction goes to low-latency models.

Complex, high-value work goes to heavier reasoning systems.

Batch jobs run in the background.

Premium users get stronger models or faster queues.

Uncertain cases escalate.

This is how AI products avoid the fatal trap: either too slow to use or too shallow to trust.

The router allows the product to breathe.

It gives the user speed when speed matters and depth when depth matters.

That is not merely optimization.

That is taste.

And taste compounds into trust.

Reason Four: Resilience and Uptime

Any system hardcoded to one provider has one throat to choke.

That is not architecture.

That is dependency.

Even the strongest AI providers can experience outages, degraded performance, aggressive rate limits, sudden behavior changes, pricing changes, policy shifts, model deprecations, capacity constraints, and regional disruptions.

If your product depends on one model endpoint, your uptime is not yours.

It is borrowed.

The router gives it back.

A serious routing layer acts as a load balancer, fallback mechanism, retry engine, and continuity system. If one provider slows down, traffic moves. If one model fails, another handles the task. If quality degrades, the evaluator catches it. If a provider rate-limits you, the system redistributes load. If an endpoint goes dark, the user never sees the wound.

This is not optional for enterprise AI.

Enterprises do not buy magic.

They buy reliability.

They want service-level agreements. They want predictable performance. They want disaster recovery. They want vendor redundancy. They want audit trails. They want to know what happens when the beautiful demo meets a Tuesday afternoon production incident.

The router is the answer.

It converts model dependency into model optionality.

It creates operational depth.

A product with no fallback plan is not an AI application. It is a hostage note.

Reason Five: Risk Mitigation

The final reason is the least appreciated and maybe the most important.

AI is becoming geopolitical infrastructure.

That means model access will not be governed only by product quality or market demand. It will be shaped by national security, export controls, licensing regimes, safety evaluations, procurement rules, data residency, privacy law, compute supply, political pressure, and whatever new institutional machinery emerges as governments realize that frontier models are not normal software.

The recent Fable/Mythos situation is a warning shot: reporting described U.S. government restrictions that forced Anthropic to disable access to advanced models after national-security concerns were raised. Whether that specific incident remains a black swan or becomes a template, the strategic lesson is obvious: model availability can become a policy variable, not a product variable.

That changes everything.

If your entire AI stack depends on a single model, from a single provider, under a single jurisdiction, with a single compliance posture, you are exposed.

Maybe the provider changes its terms.

Maybe regulators restrict access.

Maybe certain users are no longer allowed.

Maybe a model is pulled.

Maybe your industry gets classified as sensitive.

Maybe a jurisdiction demands data localization.

Maybe open weights become restricted.

Maybe closed models become approved for some uses and prohibited for others.

Nobody knows the exact path.

But only a fool waits for certainty before building optionality.

The routing layer becomes a risk mitigation engine. It lets companies shift workloads across providers, jurisdictions, deployment types, and model classes. Closed model to open model. Cloud model to local model. U.S. provider to European provider. Frontier model to approved enterprise model. General model to domain-specific model. External API to private deployment.

This is sovereignty at the software layer.

Flexibility is not convenience.

Flexibility is survival.

Intelligence Market Maker

Once you see this clearly, the router stops looking like middleware.

It starts looking like market infrastructure.

Every model is a supplier of intelligence.

Every task is demand.

The router clears the market.

It decides which supplier gets the job based on price, speed, quality, reliability, compliance, and context. It observes performance. It records outcomes. It learns which models perform best on which categories. It builds a private benchmark from real usage, not synthetic leaderboard theater.

This is extremely valuable.

Because the public leaderboard is not your workload.

Your workload has its own distribution. Your users ask specific questions. Your documents have specific formats. Your business has specific risks. Your latency tolerance is specific. Your compliance requirements are specific. Your margin structure is specific.

The best routing system learns your reality. It does not worship general benchmarks.

It builds an internal map of model performance under actual operating conditions.

That map becomes proprietary.

Over time, the router knows things the model companies do not know. It knows which model performs best on your customer base, in your workflow, under your constraints, at your price point. It knows when a model silently got worse. It knows when a cheaper model became good enough. It knows when a frontier model is worth the premium. It knows when to escalate. It knows when to refuse. It knows when to ask for clarification. It knows when to split the job into sub-jobs.

This is where applied AI companies can build durable advantage.

Not by pretending they will out-train the labs.

But by owning the orchestration layer closest to the customer.

The Stack That Wins

The winning AI stack will not be a single prompt connected to a single model.

That is toy architecture.

The winning stack will look more like this:

1. A user submits intent.

2. A classifier identifies complexity, domain, risk, urgency, and output type.

3. A planner decomposes the work.

4. A router assigns each piece to the correct model or tool.

Execution happens across a portfolio of systems.

The system works in layers:

• A policy layer checks compliance.

• A memory layer tracks context.

• A cost layer monitors margin.

• A latency layer manages user experience.

• A fallback layer protects uptime.

• A governance layer logs decisions.

The final answer appears simple.

The machine underneath is not.

This is how all serious technology evolves. The primitive interface hides the sophisticated system. The user presses one button. Behind the button lives allocation, routing, redundancy, monitoring, pricing, security, and control.

AI will be no different.

The product that feels magical will not be the one that throws every request at the biggest model.

It will be the one that makes the best allocation decision thousands of times per second.

The Strategic Advantage

This is why the routing layer will increase substantially in value.

It attacks cost.

It expands capability.

It improves speed.

It protects uptime.

It mitigates regulatory and provider risk.

It turns models into interchangeable, composable, measurable components inside a larger system of intelligence.

That is the applied AI advantage.

The frontier labs will keep building more powerful engines. That matters. Power matters. Reasoning matters. Scale matters.

But the world does not run on engines alone.

It runs on systems that deploy engines intelligently.

The company that owns the routing layer owns the decision of where intelligence flows. It can substitute providers. It can optimize margins. It can absorb shocks. It can improve product quality without rebuilding the whole stack. It can turn model competition into its own advantage.

When providers compete, the router wins.

When models specialize, the router wins.

When prices fall, the router wins.

When regulations shift, the router wins.

When outages happen, the router wins.

When user expectations rise, the router wins.

This is the pattern.

The value moves to the layer that coordinates abundance.

AI intelligence is becoming abundant, uneven, volatile, and strategically sensitive.

That is exactly the environment where routers become powerful.

Build the Control Plane

The next generation of AI products will be judged not only by which models they use, but by how intelligently they allocate intelligence.

The question will not be:

“Do you use the best model?”

The question will be:

“Can your system choose the best model for this task, right now, under these constraints, and recover instantly if that choice fails?”

That is a different standard.

It requires instrumentation. Evaluation. Cost accounting. Latency management. Provider abstraction. Fallback logic. Compliance awareness. Internal benchmarking. Taste.

It requires architecture.

And architecture is where the amateurs get separated from the operators. You can’t vibe good architecture (yet, I bet by late 2027 or early 2028 that changes).

The amateurs will keep arguing about model rankings and practicing LLM Religion.

The operators will build the routing layer.

Because the router is not just a technical component.

It is the control plane between human intent and machine execution.

In the old world, distribution was power.

In the AI world, orchestration becomes power.

The models will keep changing.

The providers will keep shifting.

The regulations will keep tightening.

The costs will keep moving.

The capabilities will keep surprising everyone.

The router is how you stay alive inside that chaos.

Do not hardcode your future to one intelligence source.

Build the layer that can move.

Build the layer that can choose.

Build the layer that can survive.

The router becomes the weapon.

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

Some argue looping is just a psychological operation (a trick) being played on them by the model houses, who naturally want us to consume as many tokens as possible. Having agents talking to themselves in circles is a great way to accomplish that.

For the last two years we prompted artificial intelligence one task at a single time. That era of manual micro management is completely over, according to the latest AI trend. We are transitioning into an age of autonomous recursive systems that compound value without human intervention.

Agent looping is the latest manifestation of technological leverage.

Systems create leverage and massive surface area you can use to drive exponential outcomes. AI is the most powerful force ever invented by human minds. It feeds boundless energy into all the other sciences, technologies, and corporate efforts across the globe. Instead of asking an agent to build a landing page and then driving every step yourself, you set up a loop that handles the entire pipeline.

You build the infrastructure and step completely out of the way.

The loop handles discovery, executes planning, does the actual work, checks the results, and iterates relentlessly until the final goal is met. Looping is a fundamental setup you build from scratch to control this intelligence. Almost any modern agent harness can run a loop right now. The financial outcome entirely depends on exactly how you wire the cognitive architecture together.

The true value lies in the rigid pathways you design.

The Mechanics of Autonomous Recursion

At its simplest level, looping is one singular agent continuously working on its own output. The agent researches the topic, drafts the initial concept, and systematically checks that draft against a rigid goal. It aggressively identifies what is weak, fixes the errors, and runs that exact cycle again until the work clears your strict requirements.

You are not prompting each individual step anymore because the agent repeats the cycle for you.

One agent looping is exactly like a single human endlessly perfecting their own draft.

The bigger and infinitely more profitable version is fleet looping. You give an orchestrator agent a massive overarching goal. It breaks the massive goal into highly specific pieces, hands each piece to a specialist agent, and those specialists hand smaller jobs to their own subagents. The entire digital tree keeps looping through discovery, planning, execution, and verification until the absolute goal is met.

A fleet looping is an entire corporate team running a project end to end.

You simply create a goal and the massive system runs the loop until it finishes within the precise requirements you set. The fleet scales your operational intent. The fleet executes your high level vision. The fleet relentlessly optimizes the final output without drawing a salary or taking a break.

I split this architecture into two distinct categories: open and closed looping.

The Frontier of Open Looping

Open looping is new.

It is also dangerous (on your wallet).

It still possesses initial conditions and a final goal but you give the agent or the fleet a massive wide space to move in. It can try completely different paths, discover novel things, and build something magnificent you did not fully spec out in advance. This is the truly exciting end of the spectrum.

It is where I want to spend the majority of my time pushing the bleeding edge.

The massive and undeniable catch with open loops is the extreme operational cost. An open loop with real room to intellectually explore burns an insane amount of computational tokens. For the ninety percent of people without an unlimited corporate budget it is absolutely not runnable yet. Pointed at complex projects with a loose standard it instantly turns into a pure slop machine.

You get vast quantities of useless output and completely destroy your operational budget.

The Dominance of Closed Looping

Closed looping is tightly bounded and rigidly structured to guarantee an immediate return on investment.

A human architect mathematically designs the end to end path first before any compute is spent. You define a clear goal, map out the precise steps, establish an evaluation at each step, and mandate a hard point where it stops or hands the process back to you. The agents still loop recursively but they remain trapped inside the framework you built.

For most marketing and development work today, closed loops are strongest.

The final product gets demonstrably better every single run because each pass directly feeds the next pass. It runs on a completely normal and highly predictable budget because the operational path is exceptionally tight. The orchestrator agent strictly owns the macro goal. The specialist agents completely own the defined sequential steps.

The subordinate subagents execute the narrow manual work flawlessly.

An evaluation gate makes absolutely sure the final deliverable is never slop. You build the rigorous evaluation systems. You deploy the cognitive digital fleets. You capture the massive exponential upside.

The evaluation gate is the ultimate enforcer of corporate quality.

The Industrialist

We must shift our mental models regarding complex labor and digital production.

You do not tell an agent to pick up a hammer and assemble a chair with a detailed design spec. The foundational models already know exactly how to do that natively. Your new job is building detailed onboarding documents, setting massive design direction, and dictating high level cultural values.

You are formalizing the decision frameworks for the new global economy.

You establish the unbreakable rules for the entire furniture factory, the massive distribution center, and the overarching global business. You must step away from the workbench and occupy the executive office of your digital empire. The shift from craftsman to industrialist requires a complete rewiring of your professional identity. You no longer swing the hammer or turn the wrench.

Then you simply hire AI workers on loop to do the actual thing.

It is very similar to the way global fast food restaurants operate at an unbelievable scale. They have standardized and extensively documented operational practices designed to eliminate human error. They utilize these rigid systems to teach dumb, unmotivated, and completely non sober high schoolers how to run a fully working restaurant. They achieve this staggering logistical feat at the massive scale of millions of global transactions every single day.

The standardized system completely overrides the individual flaws of the biological worker.

The Operational Blueprint

We are porting that exact franchise model into digital logic and compute. Except instead of producing physical burgers or wooden chairs you produce perfect code and business outcomes via software. Data flows are the lifeblood of these autonomous cognitive fast food systems. An orchestrator agent is completely useless without a pristine pipeline of context and infallible historical memory.

You must pipe clean data into the specialists so they can execute their narrow tasks.

My entire career transitioning from Investment Banking into Data Engineering taught me one permanent and undeniable truth. Capital aggressively flows directly toward the most efficient systems of scalable production. When you combine massive compute with recursive agentic loops, you create an unprecedented engine for pure wealth generation.

Imagine building wealth systems with these loops?

Wealth Systems

Build wealth systems to power your life.

By Matt McDonagh

When I evaluate tech companies as a private investor today, I look at their fundamental cognitive architecture. If they rely on humans typing single prompts into a chat interface, their entire business model is already obsolete. The free market violently punishes inefficiency and heavily rewards absolute systemic automation. The companies that survive will look like massive software factories run by a handful of elite systems architects.

Whether looping is “it”, or part of a larger group of AI control patterns, manual prompting is a complete dead end.

We will look back at ping-ponging chats with AI, and then pasting the outputs someplace else as retro.

The Empire of System Builders

There is no mathematical ceiling to the amount of value we can generate with AI.

Agent looping decouples the creation of economic value from the rigid constraints of human time. You write the complex decision frameworks once, and the autonomous system executes them a million times without fatigue. You establish the rigorous cultural values of your digital business, and the fleet embodies those exact values flawlessly.

You stop acting like a single laborer and start acting like a holding company.

The future belong exclusively to the system builders. You must abandon the outdated romanticism of manual labor and embrace the undeniable physics of digital leverage and very soon, robotics. Every single industry on this planet will be hollowed out and completely rebuilt around these looping cognitive architectures. You either adapt to this new mechanical reality or you get entirely swept away by the coming wave of automated intelligence.

We are standing at the absolute precipice of the greatest wealth transfer in the history of human civilization.

The people who understand how to orchestrate these digital fleets will command unprecedented economic power.

You have the exact same access to the foundational models as the largest corporations on earth.

The only difference between you and them is the complexity of the looping infrastructure you choose to build.

Agent looping is a powerful key to unlocking pure digital sovereignty, when used correctly.

Use it correctly!

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

Transformers created the first true platform shift in machine intelligence because they turned language into a scalable compute problem. They made prediction programmable, knowledge compressible, reasoning accessible, and software conversational. They gave us ChatGPT, Claude, Gemini, Copilot, agents, coding copilots, research assistants, and the first real glimpse of intelligence as infrastructure.

But every architecture has a shape. Every shape has an edge. Every edge eventually becomes a wall.

Transformers generate language like a typewriter. They move left to right, token by token, building the future from the past. This is elegant, powerful, and historically decisive. It also carries the fundamental limitation of sequence. The model has to walk forward one step at a time. It can be optimized, batched, cached, quantized, distilled, parallelized around the edges, and deployed across monstrous infrastructure, but the core generation pattern remains sequential.

Diffusion attacks the problem from a different angle.

Diffusion does not write language like a typewriter. It forms language like a sculptor. It starts with noise, structure, placeholders, uncertainty, and then refines the whole block toward coherence. Instead of predicting the next token in a line, a diffusion language model can work across a whole region of text at once. It can revise, reconcile, fill, correct, and converge. That changes the speed profile. It changes the hardware profile.

It changes the interface profile.

That changes the strategic map.

The transformer era taught the world that scale matters. More data, more compute, more parameters, more reinforcement, more tools, more context. The diffusion era will teach the world that shape matters. The geometry of generation determines the economics of intelligence. The architecture determines the latency, the cost, the user experience, and the kinds of applications that become possible.

This is not an academic distinction.

It is the difference between waiting for intelligence and interacting with intelligence.

Transformers Built the AI Economy

Transformers won because attention is a universal coordination mechanism.

The model looks across tokens, learns relationships, captures patterns, and predicts what comes next. That single idea turned language modeling from a narrow statistical trick into the central operating layer of modern AI. It made text generation fluent, code generation practical, reasoning emergent, and multimodal systems possible.

The transformer is an extraordinary invention because it converts context into capability. Give it a prompt, a document, a codebase, a transcript, a chart, a contract, or a thread of messages, and it can transform that context into useful output. It can summarize, classify, translate, draft, debug, persuade, plan, and execute. The modern AI stack is built on this capability. The chat interface is built on it. The agent interface is built on it. The entire enterprise AI wave is built on it.

But transformer inference has a core bottleneck. It generates output one token at a time. Even when the model has already understood the user’s goal, even when the answer is obvious, even when the structure of the response is already latent inside the model, the output still has to be emitted sequentially. This creates latency. Latency creates friction. Friction kills whole categories of applications before they ever reach the market.

This matters because the next frontier is not just smarter AI. The next frontier is ambient AI, embedded AI, local AI, real time AI, interactive AI, and agentic AI. Those systems cannot feel like a slow autocomplete box. They need to feel like electricity. They need to respond instantly, adapt continuously, and move through workflows at machine speed.

The transformer made intelligence legible.

Diffusion can make intelligence fluid.

Diffusion Is a Different Theory of Generation

Diffusion became famous through image generation. The basic concept is simple. Start with noise. Learn how to remove the noise. Repeat the process until structure appears. A face appears. A landscape appears. A product mockup appears. A world appears.

Text diffusion brings that logic into language.

Instead of generating a sentence strictly from left to right, a diffusion language model can generate a block of text through iterative refinement.

It can see the whole canvas. It can fill gaps. It can adjust earlier tokens based on later tokens. It can resolve structure across the entire output instead of being trapped by the irreversible momentum of previous guesses.

That matters for domains where the end constrains the beginning.

Code is one of those domains. A function has dependencies, imports, variables, braces, tests, return types, naming conventions, and hidden constraints. A sequential model can write code well, but it still commits as it moves. A diffusion model can treat the code block more like a complete object. It can refine the middle after seeing the end. It can close structures, resolve references, and handle infill in a more native way.

Math is another domain. So are tables, diagrams, molecules, workflows, markdown, design systems, legal clauses, and structured outputs. In every domain where the whole matters more than the next step, diffusion has a natural architectural advantage.

Transformers predict sequence.

Diffusion refines structure.

That is the difference.

Speed Is the Wedge

Speed is not a feature. Speed is a market structure.

The history of technology is the history of latency collapse.

Mainframes became personal computers. Dial-up became broadband. Batch processing became cloud. Search results became instant. Streaming replaced downloads. Mobile turned computing into reflex. Every time latency collapses, the surface area of behavior expands.

AI is going through the same transition. The first phase of generative AI tolerated latency because the outputs were magical. People accepted waiting because the capability was new. That phase is over. The next phase rewards systems that feel immediate. Developers will choose the model that keeps them in flow. Consumers will choose the assistant that responds like thought. Enterprises will choose the architecture that drives cost down and throughput up.

Diffusion has a direct path into this future because it can generate blocks in parallel. Google’s Gemini Diffusion has already demonstrated the strategic point: text diffusion can be dramatically faster while remaining competitive on important coding and reasoning tasks. DiffusionGemma makes the point even sharper. Google released an open experimental model designed specifically around faster text generation, local workflows, and interactive use cases.

That is the sound of a new architecture entering the arena.

The key economic insight is that diffusion can shift the bottleneck. Autoregressive models often become memory bandwidth constrained during token by token decoding. Diffusion can give the accelerator more work at once. That matters enormously on dedicated GPUs because underutilized compute is wasted capital. The world has spent trillions building chips, data centers, power systems, networking layers, cooling systems, model serving stacks, and developer infrastructure. The architecture that uses that hardware most efficiently gets a compounding advantage.

Speed changes cost.

Cost changes distribution.

Distribution changes power.

Google Understands the Hardware Game

Google’s diffusion push is not random. It is exactly the kind of architectural bet Google is built to make. Google has the research organization, the model family, the TPU infrastructure, the Android distribution, the Cloud platform, the browser, the productivity suite, the search surface, the developer ecosystem, and the consumer hardware footprint. If diffusion becomes strategically important, Google has more places to deploy it than almost anyone else on earth.

This is the essential point. A faster language model is not just a faster chatbot. It is a new substrate for products.

Put fast diffusion into Gmail and email becomes an active workspace. Put it into Docs and writing becomes real time collaborative cognition. Put it into Sheets and modeling becomes conversational simulation. Put it into Search and answers become dynamic generated interfaces. Put it into Android and phones become local agents. Put it into Pixel and the device becomes a personal inference machine. Put it into Cloud and enterprises get low latency agents that execute inside their operational systems.

The transformer era made AI impressive.

The diffusion era can make AI invisible.

That is where the real money is. The most valuable AI systems will not always announce themselves as AI systems. They will live inside workflows. They will shorten cycles, remove waiting, surface decisions, automate handoffs, and compound human agency. They will become the quiet intelligence layer inside every tool people already use.

Google has spent decades building those surfaces.

Now it is building the model architecture that can animate them.

The Transformer Wall Is a Deployment Wall

People talk about the transformer wall as if it means models stop getting smarter. That is the wrong framing. The wall is not only about intelligence. The wall is about economics, latency, energy, memory, context, inference cost, and product experience. A model can keep improving on benchmarks while becoming increasingly difficult to deploy in the places where intelligence creates the most value.

This is already visible. Frontier models are powerful, but the cost of serving them is immense. Long context is useful, but attention creates scaling pressure. Tool using agents are promising, but slow loops make them brittle. Coding agents can do real work, but latency compounds across multi step workflows. Voice agents need immediacy, but sequential generation creates drag. Local AI is strategically necessary, but memory and power constraints punish heavyweight architectures.

That is the wall.

It is not one wall. It is three walls: the wall of latency, the wall of cost, and the wall of interaction.

Diffusion attacks all three. Faster block generation reduces perceived waiting. Better accelerator utilization improves the cost curve in the right settings. Bidirectional refinement opens new interaction patterns where users edit, steer, regenerate, and collaborate with the model in real time.

This does not mean transformers disappear. Dominant architectures rarely vanish overnight. They become infrastructure. They get specialized, hybridized, commoditized, and absorbed. The mainframe did not vanish when personal computing emerged. Relational databases did not vanish when NoSQL arrived. CPUs did not vanish when GPUs became essential. Transformers will remain foundational. But the frontier of value moves to whatever architecture unlocks the next wave of use cases.

The next wave is speed critical, local, interactive, multimodal, and agentic.

Diffusion is built for that frontier.

Open Models Are the Distribution Weapon

The release of DiffusionGemma is strategically important because open models create ecosystems.

Open models let researchers fine tune, inspect, benchmark, adapt, deploy, and remix.

They turn a model from a product into a platform.

They let the outside world discover use cases faster than any internal roadmap ever could.

This is how architecture shifts happen. The research lab proves the direction. The open model gives builders a handle. The developer community finds the strange edge cases, the killer workflows, the unexpected benchmarks, the weird demos, the practical optimizations, and the first commercial wedges. Then the platform company absorbs the learning and scales the architecture into its core products.

Google knows this playbook. Android was not just a mobile operating system. It was a distribution strategy. Kubernetes was not just infrastructure software. It was a cloud strategy. Gemma is not just a set of open weights. It is a developer strategy. DiffusionGemma is the first serious invitation for the broader ecosystem to help turn text diffusion into a practical development path.

Open models create mindshare.

Mindshare creates tooling.

Tooling creates inevitability.

That is how a research direction becomes a platform shift.

What Google Could Accomplish If Diffusion Wins

If Google leads diffusion development while transformers hit diminishing returns, the company can reclaim the narrative of AI infrastructure.

Not by having a chatbot that occasionally tops a leaderboard, but by owning the architecture that makes AI fast enough, cheap enough, and local enough to disappear into everything.

First, Google can dominate edge intelligence. Android is the largest consumer computing platform in the world. A fast diffusion model that runs locally on phones, laptops, and dedicated consumer GPUs changes the role of the device. The device stops being a terminal for cloud intelligence and becomes an active intelligence node. That unlocks privacy, offline use, lower cost, lower latency, and sovereign deployment.

Second, Google can rebuild productivity software around real time generation. Docs, Gmail, Slides, Sheets, Meet, Calendar, and Drive can become living systems. Not static apps with AI buttons. Living systems. Documents that rewrite themselves based on intent. Spreadsheets that generate models in real time. Meetings that produce decisions, tasks, and follow through. Email threads that become negotiated action plans. Calendars that resolve conflicts like agents, not reminders.

Third, Google can turn Search into a generative interface layer. The future of search is not ten blue links or one static answer. It is dynamic synthesis, generated tools, interactive exploration, visual reasoning, personalized workflows, and direct execution. Diffusion speed matters here because users will not tolerate slow interfaces at search scale. If Google can generate structured responses, mini applications, comparisons, maps, tables, and workflows instantly, search becomes less like a website and more like an operating system for knowledge.

Fourth, Google can use diffusion to attack coding. Coding is structurally compatible with diffusion because code is not just sequence. It is graph, dependency, syntax, architecture, state, and intent. A model that can refine blocks, infill intelligently, reconcile future constraints, and generate at high speed has a direct path into developer workflows. The coding environment becomes a live canvas. The model does not merely autocomplete. It restructures, debugs, tests, explains, and modifies across the whole artifact.

Fifth, Google can compound its advantage in science. AI feeds energy into every other science. Biology, materials, robotics, climate, medicine, logistics, semiconductor design, and mathematics all benefit when models become faster and more structurally aware. Diffusion is already native to images, video, protein structures, and other non linear domains.

A unified diffusion research program across text, code, molecules, video, and physical systems gives Google a path toward models that reason across the actual shape of the world.

That is the prize.

Not a faster paragraph generator.

A general architecture for refining reality.

The Hybrid Future Is the Real Future

The winning system will not be pure transformer or pure diffusion. The winning system will be hybrid. Transformers are too useful to discard. Diffusion is too powerful to ignore. The future belongs to model systems that route tasks across architectures based on what the job demands.

Use transformers for long form reasoning, tool calls, dialogue continuity, and mature production quality. Use diffusion for low latency generation, editing, infilling, block structured outputs, local interaction, code repair, and real time interfaces. Use retrieval to ground the output. Use agents to execute. Use specialized models to perceive, simulate, and optimize. Use orchestration to make the whole system feel like one intelligence.

That is the architecture of leverage.

The mistake is treating models as isolated products. The right frame is systems. A model is a component. A workflow is a machine. A platform is a compounding surface. The companies that win AI will not merely own the biggest model. They will own the best system for turning intelligence into action.

Google is one of the few companies with enough surface area to make that system real.

Diffusion Expands the Surface Area of Agency

The ultimate measure of an AI architecture is not benchmark performance. Benchmarks matter, but they are not the whole game. The ultimate measure is agency.

Does the architecture let people do more? Does it shorten the path between intent and outcome? Does it increase the number of useful actions a person, team, company, or country can take?

Transformers already expanded agency. A single person can now write code, analyze markets, draft legal documents, build products, research industries, generate content, and operate with a level of leverage that used to require a team. That is why AI is the most powerful force invented. It feeds energy into every other effort. It turns knowledge into motion.

Diffusion expands that leverage by reducing drag.

When AI is faster, people use it more. When AI is local, people trust it more. When AI is interactive, people shape it more. When AI can refine whole structures instead of marching through sequences, it becomes useful in more domains. Speed is not superficial. Speed changes behavior, and behavior changes markets.

This is why Google’s diffusion push matters. It signals that the next architecture war has begun. The world spent the last decade scaling transformers. The next decade will be about making intelligence faster, cheaper, more local, more interactive, and more structurally aware.

Transformers gave us the first mass market intelligence engines.

Diffusion gives us the next operating layer.

The companies that understand this will build the next platforms. The companies that miss it will optimize yesterday’s architecture until the economics break under them. The market will not wait. Developers will not wait. Users will not wait. Capital will flow toward the systems that feel instant, useful, sovereign, and alive.

The future of AI is not only bigger.

The future of AI is faster, broader, and closer to the edge.

Diffusion is how intelligence stops typing and starts forming.

That is the next shift in the Singularity.

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.

Share Life in the Singularity

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?! 🙏

Leave a comment

We are going to do more unpacks and explainers like this for the paid subscribers every month. Thank you for supporting us!

Google has officially introduced Managed Agents through their Gemini API and AI Studio. This is not just another minor chatbot update or incremental feature release. This is a profound shift in how we interact with computing systems on a fundamental level. Patrick from the Gemini API team recently provided a spectacular tutorial on this very topic, showing us exactly how to bring these autonomous digital assistants to life.

A Managed Agent is a customizable AI entity that does far more than just predict the next word in a sentence. It actively reasons through complex problems, writes original code, and executes it within a highly secure environment. These agents operate inside a dedicated Google-hosted Linux sandbox. This means they have a completely safe playground to run bash scripts, manage system files, and even browse the live web to fetch real-time data for your projects. You are no longer just talking to an algorithm; you are directing a highly capable digital employee that can build software for you. And the best part is how incredibly accessible this technology has become for everyone. Whether you prefer a visual interface or diving deep into Python code, the path forward is clear.

Let’s break down how you can start building your own AI agents today.

Exploring Managed Agents in Google AI Studio

The journey to building your first agent begins in Google AI Studio.

This visual interface is designed to make complex artificial intelligence tasks feel completely intuitive. When you log into the platform, you will immediately notice a brand new Agents tab on the interface. This is your new command center for creating, testing, and deploying Managed Agents. The foundational model powering these new capabilities is called the Antigravity Agent Preview, which runs on the incredibly impressive new Gemini 3.5 Flash model. The Flash architecture is specifically designed for both blistering speed and token efficiency, making it the absolute perfect brain for an autonomous agent that needs to iterate quickly.

Watch this video first, then return to the article.

Patrick demonstrated the sheer power of this setup with a brilliant live coding example by asking the base agent to build a complete weather dashboard from scratch. The prompt he used was remarkably simple yet demanded a highly complex series of autonomous actions. He requested the current weather and a three-day forecast for the cities of London and Ankara, instructed the agent to parse this raw data using the Python programming language, and commanded it to generate an interactive HTML dashboard featuring clean CSS styling.

Watching the agent work is like watching a seasoned senior developer speedrun a weekend project. First, the agent securely spins up its remote Linux environment in the background and outlines its internal thought process logically so you can follow along. It realizes it needs to write a specific Python script to fetch the requested meteorological data, targets a known weather service website to pull the raw JSON information, and actively writes a script called generate_weather.py right before your eyes. It then runs this script inside the secure Google sandbox to verify the code works.

The agent aggregates the parsed data and begins constructing the visual user interface, utilizing modern web styling libraries like Tailwind CSS to make the final product look highly professional. All of this complex software engineering happens in a matter of mere moments. When the autonomous task is complete, you can simply download the generated files directly to your machine. Patrick opened the resulting HTML file to reveal a stunning interactive dashboard that featured elegant dark mode styling, highly accurate data points, and dynamic hover elements that a human developer would normally spend hours tweaking. This single natural language command successfully replaced a massive amount of manual coding. This is the exact kind of accelerating techno-optimism we celebrate here.

We are rapidly moving from writing tedious syntax to simply directing goals and watching agents autonomously achieve high-level outcomes.

You are effectively building a custom software entity.

Let’s dive deeper now!

Read more

Cash is a melting block of ice in a scorching hot sauna.

Every unit of currency sitting idle in a bank account is actively bleeding purchasing power by the second. The financial system is explicitly structured to penalize prudence and drive consumption. They want you gambling your wages on leveraged, speculative slop. They want you constantly spinning the wheel to outpace the decay of your own money.

They want to make saving the fruits of your labor an impossible physics problem for the working class.

In the modern fiat regime, money not deployed into compounding systems is money destroyed. But we are standing at the precipice of a technological shift so profound that it will shatter the legacy financial apparatus entirely. Artificial intelligence is about to drive the marginal cost of everything to zero, creating a world of limitless abundance. And to contain the value of that infinite abundance, the world requires an anchor of absolute scarcity.

That anchor is Bitcoin.

AI will be the ultimate catalyst that drives exponential value directly into the Bitcoin network. Here is why the fusion of artificial intelligence and Bitcoin is a mathematically inevitable symbiosis.

The TradFi Apparatus Operates on Provable Deception

To understand why AI and Bitcoin fit together perfectly, you first have to understand the fundamental lie of the legacy system.

Wealth managers parade massive nominal returns in front of their oblivious clients. They point to stock charts moving up and to the right with unearned pride. They sell this rampant currency debasement as a monumental success story. The masses look at these inflated numbers in their retirement accounts and feel rich, completely oblivious to the fact that their actual ability to acquire physical assets (homes, land, energy, raw materials) is permanently plummeting.

They are blind to the theft occurring in broad daylight.

Inflation is an engineered phenomenon designed to steal your time and transfer it to the elite. The continuous transfer of wealth from the builders to the bureaucrats is a deliberate feature of fiat architecture, not a bug.

When a central bank expands the money supply, it doesn’t create new wealth. It simply dilutes the purchasing power of the currency already in circulation. It steals the stored energy from the working class who hold cash, and hands it to the asset-heavy elite who hold real estate and equities closest to the money spigot.

We have lived under this paradigm for decades, conditioned to accept that prices must universally rise. But this directly contradicts the fundamental laws of technological progress.

The Clash of Two Paradigms

The laws of technological progress dictate that prices must fall. Software eats fixed costs. Artificial intelligence drives marginal production costs to absolute zero. Automation obliterates all human friction in the supply chain. We are actively building systems of infinite leverage that should make everything universally abundant and drastically cheaper.

The cost of living should be dropping at an exponential rate. The cost of intelligence certainly is!

Yet, we live in a schizophrenic economy. We have an underlying technological reality that is aggressively deflationary, trapped inside a monetary system that is aggressively inflationary. When technology makes a process 50% cheaper, the central banks simply print enough money to hide the efficiency gain, absorbing the surplus value for themselves and their cronies while keeping prices artificially high for the consumer.

AI is accelerating this deflationary trend to the point of a singularity. As AI systems learn to write code, design infrastructure, diagnose diseases, and automate logistics, the actual cost of human survival should plummet toward zero.

But it won’t.. not under fiat.

Bitcoin is the Opt-Out

Bitcoin is the final exit from this rigged game because Bitcoin is a network that nobody can dilute, censor, or defile.

It is the definitive opt-out from an architecture that manipulates the base layer of reality against our survival. Bitcoin protects your stored energy from this relentless racket. As the legacy financial system accelerates its own demise through infinite money printing this immutable protocol absorbs all the escaping capital.

Think of Bitcoin as an impenetrable vault for human energy. When you work, you convert your time and physical output into money. If that money can be printed by bureaucrats at zero cost, your energy is being siphoned away. By storing the units of your labor in a network of 21 million mathematically secured coins you achieve financial sovereignty.

We are gaining sight in a land of the blind and the poor. Stop participating in a game where the rules are changed mid-match to ensure the house always wins. Leverage technology to multiply your physical output, and store the resulting capital in a system of absolute truth.

The fiat baseline is melting away. Central banks are backed into a corner. They cannot stop the exponential march of AI, nor can they stop the relentless printing required to service tens of trillions in sovereign debt.

The only logical move for any rational economic actor is to flee the melting ice cube and step onto the solid bedrock of cryptographic scarcity.

Infinite Abundance Demands Absolute Scarcity

This brings us to the core economic philosophy of the 21st century: AI is bringing unlimited abundance, which means we NEED absolute scarcity.

Value is derived from scarcity.

If AI makes intelligence, code, art, legal analysis, and logistical planning infinitely abundant, the monetary premium attached to those skills will collapse.

When you can generate a blockbuster movie, a flawless software application, or a brilliant legal defense for fractions of a cent, where does the stored value of the global economy go?

It has to flow into what cannot be replicated. It has to flow into the finite.

AI is the master deflationary force. It will flood the zone with so much efficiency, productivity, and digital abundance that traditional metrics of GDP and corporate valuation will break down. In a world where the cost of production drops to zero, fiat currency becomes completely unmoored from reality. How do you price infinite digital goods with infinitely printable fiat currency? You get hyperinflationary math that tears the social fabric apart.

Bitcoin’s absolute scarcity is the only vessel that can contain all the value AI is going to create.

Just as a massive surge of electrical current requires a heavy-gauge copper wire to handle the load without melting, the massive surge of economic productivity generated by AI requires a monetary network with unyielding structural integrity. Bitcoin’s fixed supply of 21 million coins acts as the perfect measuring stick for a rapidly expanding digital universe. As the denominator (Bitcoin) remains fixed, and the numerator (goods, services, intelligence created by AI) expands infinitely, the purchasing power of each Bitcoin will skyrocket.

You are not just buying digital money in BTC.

You are buying a percentage of the finite canvas upon which the infinite future of AI will be painted.

What is that worth? What is going to be worth?

The Machine Economy Native Currency

We are entering the era of agentic commerce.

The symbiosis between AI and Bitcoin goes far beyond macroeconomic philosophy. It is a hard-coded engineering reality. AI agents are going to prefer Bitcoin as their wallet.

Autonomous AI systems are no longer just chatbots, they are independent economic actors. They research, negotiate, contract, and execute complex workflows across the internet. An AI agent might need to purchase cloud computing power, scrape a paywalled dataset, hire a sub-agent to translate a document, and deploy a web server… all in a matter of seconds.

To do this, the AI agent needs money. But traditional finance is fundamentally broken for machines.

Try explaining traditional banking to an AI. Every bank account, credit card, and payment processor requires Know Your Customer verification tied to a biological human. An AI agent does not have a passport. It does not have a Social Security number or a utility bill. It cannot walk into a Chase branch and open a checking account. The traditional financial system assumes a human at the other end of every transaction, moving at human speed (business days, clearing houses, wire limits).

Machine-to-machine commerce requires finality measured in milliseconds, not days. It requires micropayments of fractions of a cent, not $30 wire transfer fees.

Crypto wallets bypass all these constraints, and the Bitcoin Lightning Network is already emerging as the payment rail of choice for the machine economy. Protocols like L402 (an evolution of the internet’s HTTP 402 “Payment Required” status code) are actively being deployed to allow AI agents to interact with paywalled APIs using Lightning network micropayments.

When an AI agent needs a resource, it queries a server. The server responds with an invoice. The agent instantly pays the invoice over the Lightning network, receives cryptographic proof of payment, and accesses the data, with zero human intervention, no API keys, and no monthly subscriptions.

Why AI Will Choose Bitcoin Over Fiat Tokens

While some argue that AI agents will just use dollar-pegged stablecoins, first-principles logic dictates that an artificial superintelligence will eventually recognize the inherent flaws in fiat-backed tokens.

If you ask an advanced LLM to evaluate the properties of money it overwhelmingly ranks Bitcoin as the superior asset. Do it right now as an experiment. See what I mean?

AI loves all the qualities of bitcoin: durability, portability, fungibility, verifiability, divisibility, and scarcity.

A highly rational, calculating machine intelligence will not want to store its retained earnings in a stablecoin that can be blacklisted by a centralized issuer or degraded by a central bank’s inflation targets.

Agents will use Bitcoin for their deep treasury, and transact on layer 2 solutions like Lightning.

Imagine millions of AI agents operating 24/7, generating profits by optimizing supply chains, arbitraging decentralized finance markets, and selling digital services. As these agents accumulate capital, they will sweep their profits into the most secure, un-censorable, and mathematically sound asset on the planet. They will self-custody Bitcoin. They will run their own Lightning nodes. They will become autonomous capital allocators that recognize the provable deception of TradFi and outright reject it.

The Path to $1 Million and Beyond

This convergence is the ultimate black swan for the legacy financial system.

Wall Street currently views Bitcoin as a volatile tech stock, the NASDAQ on steroids.

Most fail to see that Bitcoin is the base money for the next evolution of the internet. When you combine the macroeconomic flight to safety from melting fiat currencies with the microeconomic adoption of Bitcoin by autonomous AI agents, the demand shock will be unprecedented.

The math is ruthless. We have a fixed supply of 21 million coins. Millions of those are already lost forever. The remaining liquid supply is tightly held by strong hands who understand the physics of the system and refuse to part with their stored energy for melting fiat paper.

Into this environment of absolute scarcity, we are about to introduce the greatest wealth-generating engine in human history: Artificial Intelligence. The productivity gains will be measured in the tens of trillions of dollars. Traditional equities will be disrupted. Real estate will lose its monetary premium as remote work and automated construction drive down property values. Bonds will become toxic waste as fiat inflation accelerates to mask the tech deflation.

Where does all that displaced capital go?

Where do the AI agents store their accumulated wealth?

It funnels into the single asset that cannot be debased, stopped, or manipulated. The idea of Bitcoin reaching $1,000,000 is not a dream. It is a conservative mathematical baseline when you account for the sheer volume of global liquidity that AI will force into the network. The current market capitalization of Bitcoin ($2T) is a microscopic rounding error compared to the total addressable market of global stored value, which is desperately seeking a safe harbor.

The Final Exit

We are witnessing the end of the fiat experiment.

The continuous transfer of wealth from the builders to the bureaucrats is ending. The engineered inflation designed to steal your time is being exposed.

AI will not drain the ecosystem of liquidity. It will hyper-financialize the world and demand a hard-money settlement layer to function. It will bring unlimited abundance, and it will pour the value of that abundance directly into the immutable scarcity of the Bitcoin protocol.

Do not be the last person holding a melting block of ice.

Stop gambling on a rigged wheel and stop letting wealth managers siphon away your purchasing power with nominal illusions.

Leverage the technology of tomorrow to multiply your output today, and store the life force of your labor in the only network that respects your time.

Bitcoin is the definitive opt-out. It is the perfect vehicle to capture the value of the AI revolution, and it is the final exit from a dying system.

If you find this kind of conversation about AI, Bitcoin and the future of wealth… subscribe to Wealth Systems:

Wealth Systems

Build wealth systems to power your life.

By Matt McDonagh

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.

Share Life in the Singularity

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?! 🙏

Leave a comment