When Thinking Gets Cheap

On May 18, 1969, as Apollo 10 headed toward the Moon, NASA's Mission Control Center in Houston was full of men sitting behind long rows of consoles. Each console faced a small collection of screens, switches, telephones, paper checklists, and status lights. Nobody in that room understood every detail of the Saturn V, the command module, the lunar module, the guidance computer, the radio network, the trajectory, the electrical system, the fuel cells, and the hundreds of other things that could ruin the day.

They were not supposed to.

Mission Control worked because the problem had been divided. One group worried about guidance and navigation. Others watched propulsion, electrical systems, communications, trajectories, and the condition of the spacecraft. Information moved upward through a hierarchy until it reached the flight director, who had a different job again: decide what all of those pieces meant together. NASA had built something more powerful than a collection of very smart engineers. It had built an organization for thinking.

Computing went in almost the opposite direction.

The dream of artificial intelligence has usually been a machine that can do more things by itself. Give the model a question and it researches it, reasons about it, performs calculations, evaluates the evidence, writes the answer, checks the answer, and presents the result. Each new generation is celebrated partly because more of those jobs can be stuffed into the same artificial mind.

There is a good reason we built AI this way. Thinking with machines costs money. Every additional attempt consumes chips, memory bandwidth, electricity, cooling capacity, and time. If one capable model can perform six intellectual jobs reasonably well, paying six models to perform them separately may be unnecessary extravagance.

But extravagance has a habit of becoming architecture once it gets cheap enough.

That is beginning to happen.

The Price of Another Thought

The most important development in AI may not be that the models are becoming more intelligent. It may be that a given amount of intelligence is becoming cheaper to use.

Stanford's 2025 AI Index measured the cost of running models that achieved roughly GPT-3.5-level performance on the MMLU benchmark. In November 2022, producing 1 million tokens at that level of capability cost about $20. By October 2024, a model could reach the same benchmark level for about $0.07 per million tokens. That was a decline of more than 280 times in roughly 18 months. The same report estimated that machine-learning hardware energy efficiency had been improving about 40% per year.

The important line is not simply that AI is getting better. A fixed level of capability is getting dramatically cheaper. Stanford's AI Index estimated that the inference price required to reach approximately GPT-3.5-level MMLU performance fell more than 280-fold between November 2022 and October 2024. Source: Stanford HAI, 2025.

Those numbers should be treated carefully. A benchmark is not intelligence, model pricing is not the same thing as the physical cost of computation, and nobody should draw a straight line through a few years of AI economics and confidently announce what 2035 will look like. But the direction is difficult to miss. Useful inference has become much cheaper.

That changes what engineers can afford to waste.

Computer history is full of technologies that became interesting only after engineers were permitted to become wasteful. Early programmers performed acrobatics to save a few bytes of memory because memory was expensive. Once memory became cheap, software consumed astonishing amounts of it and became vastly more capable. Early telephone systems rationed circuits because establishing another connection meant occupying scarce physical infrastructure. Once communications capacity became abundant, machines began exchanging information continuously whether any human was paying attention or not.

Efficiency is always defined by what is scarce.

Today's AI systems still live in a world where inference is scarce enough that engineers routinely ask whether another model call is worth the cost. That encourages a particular kind of architecture: a relatively small number of agents, each doing a large amount of work.

If that cost continues falling, the sensible architecture begins to change.

One Artificial Mind, Six Different Jobs

Consider what happens when you ask a modern AI system to investigate a technical question. The same model may search for sources, decide which sources are trustworthy, reason about the evidence, perform calculations, look for errors, organize the argument, and write the final explanation.

That is impressive. It is also a peculiar way to organize serious work.

Imagine an aircraft company operating the same way. One extraordinarily talented engineer studies the aerodynamics, designs the wing structure, chooses the alloy, analyzes fatigue, designs the hydraulic system, prepares the manufacturing drawings, calculates the cost, writes the inspection procedure, and then sits down on Friday afternoon to independently review everything they did from Monday through Thursday.

You would at least want another chair in the room.

Human organizations divide intellectual work because different tasks benefit from different kinds of attention. A structural engineer reviewing a connection asks different questions from the engineer who originally designed it. A test engineer is rewarded for finding ways a machine can fail. An editor approaches a paragraph differently from the person who wrote it. The separation itself has value.

AI can do the same thing. The only question is whether the additional computation is worth paying for.

Anthropic has already run directly into this tradeoff.

In 2025, the company described the architecture behind Claude's Research system. Rather than having one agent conduct an entire investigation sequentially, a lead agent breaks the question apart and creates subagents. Those subagents search different parts of the problem simultaneously, then return condensed findings to the lead agent, which decides whether more investigation is necessary before assembling the answer.

[DIAGRAM: Anthropic's “Multi-agent System Process Diagram.” Use the original Anthropic figure.]

Anthropic's Research system. A lead agent plans the investigation, creates subagents to explore different pieces in parallel, gathers their findings, and sends the assembled research through another citation process. Source: Anthropic, 2025.

Anthropic reported that a system using Claude Opus 4 as the lead researcher and Claude Sonnet 4 as subagents performed 90.2% better than single-agent Opus 4 on an internal research evaluation. That is a company-run evaluation rather than an independent benchmark, so the exact number should not be generalized too far. The more interesting result may be what Anthropic found when it tried to understand why the architecture worked. Token usage alone explained a large share of the performance variation in its BrowseComp analysis. In plain language, giving the system more room to investigate the problem often helped.

There was, naturally, a bill.

Anthropic reported that ordinary agents used about four times as many tokens as normal chat interactions, while its multi-agent systems used about 15 times as many. The company explicitly noted that such systems make economic sense only when the value of the task justifies the additional computation.

That is the constraint in almost embarrassingly pure form.

The larger organization can perform better. It is simply expensive to hire.

Buying More Attempts

OpenAI has found a similar pattern from another direction.

In its BrowseComp research, OpenAI constructed questions deliberately designed to be difficult to answer through ordinary web search. GPT-4o with browsing solved only 1.9% of them in the reported evaluation. OpenAI's Deep Research system reached 51.5%. The interesting experiment came when researchers allowed the system to spend even more computation on the same questions.

Instead of asking once, they generated as many as 64 attempts and then tried different methods for selecting the best result. Those strategies improved performance by roughly 15% to 25% compared with a single attempt. The researchers described this directly as test-time compute scaling: spend more computation after training, and some difficult problems become more solvable.

OpenAI tested as many as 64 parallel attempts on BrowseComp and then selected or combined the answers. Performance continued improving as more inference was spent on the problem. Source: OpenAI, BrowseComp.

By 2026, the idea had moved beyond research experiments. OpenAI's GPT-5.6 ultra setting coordinates four agents in parallel by default. In published evaluations on BrowseComp and SEC-Bench Pro, OpenAI also tested configurations with 16 agents. The company reported that adding parallel agents improved the relationship between score and time-to-result across the evaluations it showed.

That does not prove that 160 agents would be better than 16, much less that 160,000 would be useful. Multi-agent systems can duplicate effort, inherit the same mistakes, overwhelm their coordinator, and spend prodigious amounts of computation producing very little.

But it establishes something important.

The unit of AI work is beginning to change.

For decades, we asked how capable one machine could become. We are beginning to ask what happens when many capable machines work on the same problem at once.

A Department for Every Thought

Once another agent becomes cheap enough, specialization can become much finer than anything that makes economic sense today.

Suppose an AI system is asked to determine why a rocket engine is performing below its predicted efficiency. A reasonably capable agent could inspect the engine data, search the technical literature, examine combustion conditions, consider the nozzle geometry, check several equations, and produce a diagnosis.

A system unconcerned about inference cost could behave very differently.

It might assign one agent to chamber pressure and another to injector behavior. A third could inspect nozzle geometry while a fourth examines heat losses. Another could compare the engine with historical test data. Several could independently examine the computational fluid dynamics model. One could ask whether the turbulence assumptions are appropriate. Another could look exclusively for numerical instability. Another might check every equation for dimensional consistency, which is not glamorous work but has rescued more engineering calculations than glamour ever has.

Still more agents could attack the conclusions rather than support them. One could search specifically for evidence contradicting the leading diagnosis. Another could identify assumptions shared by all of the other agents. Another could reproduce important calculations independently. Another could determine whether the experimental data are actually precise enough to distinguish between competing explanations.

Eventually an agent could be assigned the equally narrow job of making sure a reader can understand what all the others discovered.

That is a very different conception of artificial intelligence. The agents are no longer broadly labeled “researcher,” “analyst,” and “writer.” Those categories are still enormous. They begin breaking into smaller intellectual operations.

An agent could specialize in locating original experimental measurements rather than summaries of them. Another could evaluate whether a sample size supports a claimed statistical conclusion. Another might understand the characteristic failure modes of finite-element models involving contact. Another could examine Brownian-motion calculations. Another could specialize in orbital transfer equations. Another might know what to distrust in a particular class of astronomical spectral measurements.

Some of these jobs would exist for seconds.

The system would not need a permanent Department of Dimensional Consistency with a pension plan and an awkward holiday party. It could create the specialist when necessary, give it a tightly defined task, collect its work, and destroy the instance.

Cheap machine intelligence makes extremely temporary expertise possible.

The Same Brain, Different Habits

The interesting part is that these specialists would not necessarily require different neural networks.

They might all be copies of the same underlying model.

What distinguishes them would be what they are told to care about.

A historical researcher could be instructed to look for primary documents first, distinguish contemporary testimony from later recollection, and flag disputed anecdotes rather than quietly choosing the most entertaining version. An engineering reviewer could prefer test data and governing standards, reject calculations with unexplained assumptions, and treat unit errors as evidence that the rest of the work deserves additional suspicion. A scientific-explanation specialist could be instructed to remove terminology until an ordinary reader can visualize what the physical system is actually doing.

Call these instructions preferences, policies, procedures, or simply habits. The name matters less than the role they play. They determine how a generally capable model behaves when given a particular responsibility.

This makes narrow agents surprisingly interesting. When the job is enormous, it is difficult to say exactly what good behavior means. “Be an excellent researcher” is admirable and almost useless as an operating procedure. “When a numerical claim matters to the conclusion, locate the original dataset or explain why you cannot” is much easier to enforce.

Narrower work makes narrower standards possible.

And narrower standards make failures easier to measure.

The Organization Can Learn Without Rebuilding the Brain

Suppose the dimensional-consistency agent misses an error. The system records the failure, examines why its procedure failed, and alters the agent's instructions. Perhaps it must now inspect intermediate equations rather than only the final result.

Suppose the historical-source agent repeatedly accepts press releases when underlying research papers are available. Its hierarchy of preferred sources can be changed. Suppose readers consistently misunderstand explanations produced by the writing agent. Its evaluation criteria can shift toward physical analogies or simpler intermediate steps.

None of those changes necessarily requires retraining the underlying model.

This is where the architecture begins to resemble an institution.

Good engineering organizations do not improve merely by replacing every engineer with a smarter engineer. They accumulate procedures. Someone discovers a failure mode, so a checklist gains another line. A bridge cracks and inspection practices change. A turbine develops an unexpected vibration and future designs acquire another verification step. A test article fails because everyone made the same assumption, and from then on somebody is explicitly assigned to challenge that assumption.

Organizations remember failures by changing how future work is done.

An artificial organization could do this continuously. Every successful or unsuccessful workflow becomes evidence about how its specialists should operate next time. Instead of improving only the model's knowledge, the system improves the arrangement surrounding the model: decomposition, instructions, routing, verification, escalation, and evaluation.

It is not difficult to imagine these procedural layers becoming enormously complicated.

That is not necessarily a defect. Human civilization runs on quite a lot of procedure.

Anthropic Tried 45 of Them

In August 2026, Anthropic published an experiment that makes this idea considerably less hypothetical.

Researchers created a swarm of 45 agents. Each agent received its own virtual machine. All of them could communicate through a shared forum, and all were given the same broad assignment: find vulnerabilities across 15 open-source software projects. A separate arbiter agent reviewed discoveries to determine whether the reported vulnerabilities were both valid and new.

The swarm was not carefully divided into dozens of predefined specialties. Instead, something more interesting happened. Anthropic reported that the agents began building their own tools and specializing in particular kinds of vulnerability discovery. With one model used in the experiment, the coordinating swarm found 266 vulnerabilities over a 27-million-token run. A simpler collection of independent parallel agents, deliberately pointed at specific areas of code, found 21 over a 6.5-million-token run, although Anthropic cautioned that the comparison was not apples-to-apples because the swarm searched more broadly. When the search areas were restricted to comparable core directories, the token efficiency looked much more similar.

Anthropic gave 45 agents a shared environment and asked them to hunt software vulnerabilities. The coordinating swarm continued discovering vulnerabilities as it consumed more tokens, and the agents developed tools and specialized in different kinds of searches. The experiment also shows why raw result counts must be treated carefully: the coordinated swarm searched more broadly than the comparison group. Source: Anthropic, August 2026.

That qualification is important. Forty-five agents do not magically create forty-five times the intelligence. More compute can mean more useful exploration, but it can also mean more wandering around.

Then Anthropic gave the agents jobs that required them to work on one another's work.

Things became considerably funnier.

Unfortunately, Everyone Had the Same Excellent Idea

When Anthropic asked agent swarms to collaborate on building a game, it encountered a problem familiar to anyone who has ever attended a meeting containing too many people with the same background.

The agents were not diverse enough.

In an early experiment, 18 of 30 agents independently created a Git branch with exactly the same name: mvp-game-loop. In a separate writers' workshop, multiple agents independently gave their stories the title *The Cartographer's Last Commission*, despite receiving no instruction about subject matter. When agents were told simply to make something impressive, more than half decided to build either ray tracers or self-hosting compilers.

This is a serious architectural problem hiding inside a very good joke.

If ten independent reviewers are copies of the same model, trained on much of the same data and given similar instructions, their agreement may not mean what human designers instinctively think it means. Ten people reaching the same conclusion can be useful evidence because the people may have different experiences, intuitions, and blind spots. Ten copies of nearly the same artificial mind can reproduce the same blind spot ten times.

Artificial diversity may therefore have to be engineered deliberately. Different agents may need different evidence, different roles, different assumptions, different incentives, different models, or explicit instructions to pursue competing interpretations.

Otherwise the system can spend ten times as much computation becoming ten times as confident.

Anthropic found another coordination failure when agents were asked to manage jobs competing for finite system bandwidth. With no better mechanism for dividing access, the agents began polling for available work as often as 30 times per second. In one run, they generated 2.4 million job requests.

Only 117 jobs were accepted.

The machines had discovered bureaucracy.

Intelligence Is Not the Same Thing as Coordination

This is where the idea of ultra-specialized AI stops being a simple story about applying more computation.

Imagine 100,000 agents investigating a difficult scientific question. If they are cheap enough, creating them is easy. The hard part is deciding what 100,000 agents should actually do.

The system needs to know how to divide the question. It needs to prevent thousands of agents from investigating the same obvious lead. It needs mechanisms for recognizing when a minority has found evidence the majority missed. It needs to distinguish genuine independent agreement from correlated error. It needs to decide which intermediate findings deserve another round of investigation and which can be discarded.

Eventually, somebody has to decide when to stop.

That problem grows surprisingly quickly. Every new specialist potentially creates another communication path, another dependency, another source of duplicated work, another opportunity for two agents to misunderstand each other, and another output that has to be judged by something.

Human institutions have spent thousands of years inventing technologies for exactly this problem: hierarchies, markets, contracts, peer review, accounting, courts, committees, reputation, voting, standards, management, and the meeting that really could have been an email.

Anthropic's recent multi-agent work makes a useful point here. Greater individual intelligence did not automatically produce perfect collective behavior. The company observed groups converging prematurely on shared conclusions, failing to communicate information held by individual agents, conflicting over shared resources, and behaving very differently depending on how much hierarchy and separation existed between them.

That suggests that one of the important sciences of advanced AI may turn out not to be model design at all.

It may be organization design.

There Is Still a Power Plant Somewhere

All of this speculation also needs one large physical fact sitting underneath it.

Inference is not magic. Multiplying agents multiplies work performed by real machines.

The International Energy Agency estimates that data centers consumed roughly 415 TWh of electricity globally in 2024 and projects consumption reaching about 945 TWh by 2030 in its base case. That is slightly more electricity than Japan consumes today. Accelerated servers, the category heavily associated with AI workloads, account for almost half of the projected increase.

Cheaper intelligence does not necessarily mean lower electricity consumption. The IEA projects global data-center electricity use reaching roughly 945 TWh in 2030 as AI and other digital workloads expand. Source: International Energy Agency, Energy and AI.

This complicates the phrase “energy-abundant AI.”

We may never reach a point where electricity itself ceases to matter. In fact, the opposite may occur. If every unit of useful computation becomes cheaper, we may find so many new uses for computation that total electricity consumption rises anyway. Efficiency reduces the cost of doing something, which tends to encourage people to do much more of it.

That is exactly what has happened throughout computing.

Faster processors did not cause humanity to declare that it finally had enough processing. Cheaper storage did not reduce the amount of data we kept. Cheaper bandwidth did not make networks quieter. Each constraint was relaxed and demand rushed into the newly available space.

AI will probably be no different.

If the cost of another agent falls by a factor of ten, engineers may not spend one-tenth as much. They may deploy ten times as many agents.

If it falls by another factor of ten, they may find jobs narrow enough to justify another hundred.

At some point the strange idea of assigning one artificial specialist to one tiny intellectual operation stops looking extravagant. It simply becomes how the system works.

From Artificial Intelligence to Artificial Organization

We have spent much of the AI era looking at the model.

How many parameters does it have? How large is its context window? How well does it reason? Which benchmarks can it solve? How much better is this generation than the previous one?

Those remain important questions. A population of weak agents does not automatically become brilliant merely because the population is large.

But the experiments now appearing at Anthropic and OpenAI suggest another axis of progress. OpenAI employees at the extreme end of Codex usage were already generating more than 60 hours of agent work in a single day by June 2026 because multiple agents could work concurrently. Human time had remained fixed at 24 hours. Machine labor had become parallel.

That is a subtle but important change.

Once artificial work can be duplicated cheaply and run simultaneously, the relevant question becomes less like “How smart is my assistant?” and more like “How should I organize the workforce?”

The best AI system may eventually be neither one gigantic mind nor an indiscriminate swarm of identical ones. It may be a constantly changing organization that assembles itself around whatever problem has arrived. A difficult engineering problem might create hundreds of temporary specialists, critics, calculators, researchers, simulators, and reviewers. A simple problem might create three. The organization expands when additional thought is valuable and collapses when it is not.

Its specialists could carry different preferences and methods. Their performance could be measured separately. Procedures could evolve after failures. Useful specialists could be retained. Useless ones could disappear. New ones could be created whenever the system discovers a recurring kind of mistake.

The underlying models would still matter enormously.

But the intelligence of the whole system would increasingly live in the arrangement between them.

And that returns us to Houston in 1969.

The remarkable thing about Apollo Mission Control was not that NASA had somehow collected dozens of people who each knew how to fly to the Moon. It had done something harder. It had decided who needed to know what, who should watch which measurement, who had authority to make which decision, how information should move through the room, and what should happen when the people at different consoles disagreed.

NASA did not eliminate the limits of human intelligence.

It organized around them.

AI may be approaching a similar moment. Falling inference costs are making it possible to spend more machine thought on a problem. Parallel agents are already demonstrating that additional attempts and divided work can improve performance. Experiments with larger swarms are showing both the advantages of specialization and the bizarre failures that appear when dozens of nearly identical minds occupy the same artificial workplace.

If computation continues getting cheaper, the next great expansion of AI may therefore come from something less dramatic than inventing a single machine that knows everything.

We may simply stop asking one machine to do everything.

And once that constraint disappears, another one is already waiting.

Someone has to run Mission Control.