After the Wall

The Wall

In 1965, Gordon Moore noticed something that would govern the next six decades of computing. The number of transistors you could fit on a silicon chip was doubling approximately every two years, and because more transistors meant more compute, this meant that processing power was growing reliably at roughly the same cost.

A transistor is a switch, either on or off, and everything a computer does is built from millions of these switches operating in precise coordination. The smallest transistors being manufactured today are roughly twelve atoms wide. The next generation will be around eight. The problem appears when you try to go further, toward four or five atoms wide, because at that scale the rules that govern how electrons behave change fundamentally.

In the world we experience, a wall stops things from passing through it. At the scale of a few atoms, electrons do not behave like objects that can be stopped. They behave more like waves, and waves have a probability of appearing on the other side of a barrier even without passing through it. This is called quantum tunneling, and it means that a transistor with walls only a few atoms thick will leak electricity even when it is switched off. A switch that leaks when it is off is not a reliable switch, and computing built on unreliable switches cannot function correctly.

The End Of Shrinking

The scientists and engineers who map the future of this industry have formally acknowledged that shrinking transistors further is approaching its physical limit within this decade. This is not an engineering problem that more investment will solve. It is a boundary set by the behavior of matter at small scales, and matter does not negotiate. No amount of money changes what an electron does at four atoms wide.

For sixty years, when anyone asked how to get more computing power, the answer was the same every single time: wait two years and the chip gets better. That answer is gone.

The Bet That Is Expiring

Every major AI system being built and deployed today, including the ones released this week, is trained and run on GPUs. Graphics processors were originally designed to accelerate 3D rendering, but their ability to run enormous numbers of mathematical operations simultaneously made them well suited for the matrix multiplications at the heart of neural network training. As Moore’s Law kept delivering more powerful chips, AI researchers used that growing capacity to train increasingly large models, and for a period this produced dramatic improvements in what AI could do.

The difficulty is that AI’s appetite for compute grew considerably faster than Moore’s Law could feed it. The compute required to train the most capable models has been doubling roughly every six months, while hardware capacity at the same cost doubled every two years. The gap between what AI needed and what hardware could provide was real, but it was being covered by spending more money, building larger clusters of chips, and accepting that training frontier models would cost tens or hundreds of millions of dollars.

The Age of Brute Force Scaling

As long as hardware kept improving, this approach made sense. Spending heavily today meant cheaper and faster models in two years when the next chip generation arrived. But when hardware stops improving at its historical rate, the economics change entirely. The models that exist today require large data centers to run, consume electricity at a scale that would be significant for a mid-sized city, and depend on hardware that most of the world neither owns nor can afford to access. If the next chip generation does not deliver the expected efficiency gains, these costs do not become temporary. They become permanent. They become the floor. And the floor is currently out of reach for most of the world.

This is the problem that cannot be waited out. The only path is to build the models themselves differently.

One Bit

To understand what building models differently means, it helps to start with how a standard model stores information. The fundamental unit of computing is a bit, a single value that is either zero or one. Standard numbers in a computer are represented using sixteen or thirty two bits combined, which allows for precise decimal values with long decimal points. Every weight inside a large language model, and a seven billion parameter model has seven billion of them, is stored as one of these sixteen-bit numbers. Before such a model can answer a single question, all seven billion of those numbers need to be loaded into memory, which amounts to fourteen gigabytes for the weights alone. When you add the memory the model needs while it is actually running, the total reaches sixteen to eighteen gigabytes. Most mid-range Android phones today ship with four.

A one-bit model stores each weight as one of just three values: plus one, minus one, or zero. Three possible values require log base two of three bits to represent, which is approximately one point five eight bits per weight. For a seven billion parameter model, the weights fall from fourteen gigabytes to roughly one point four. With the full memory a running model needs, the total lands at three to four gigabytes.

From High Precision Weights to One Bit Representations

The obvious question is what gets lost. The honest answer is: less than you would expect, and the reason is important to understand.

Weight distributions in large trained networks are not uniformly random. They cluster. A significant portion of weights in any trained model carry redundant information. The network has concentrated what it learned into a subset of its parameters, and much of the numerical precision stored across the remaining billions of weights is overhead the model works around rather than uses. When a model is trained with the one-bit constraint present from the very first step, not compressed after the fact but built within it from the beginning, the training process learns to represent everything it needs within those three values. It adapts to the constraint rather than having the constraint imposed on it later.

The result, at the scales that have been rigorously tested, is a model that matches full precision equivalents on most standard benchmarks. Whether every capability survives at every frontier scale is a question the research is still working through. What is already established is enough to matter: capable, useful intelligence, running on a phone.

And because every weight is now plus one, minus one, or zero, the model no longer needs to multiply. Every calculation becomes an addition, a subtraction, or nothing at all. Floating point multiplication, among the most computationally expensive operations a processor performs, disappears entirely from inference. The model is faster, simpler, and uses meaningfully less power.

The model runs on the phone. And that single fact restructures everything about who pays for intelligence, who controls it, and who gets it.

Who Gets Intelligence

Every time someone sends a question to a large AI model today, a GPU somewhere answers it. GPU clusters running without pause, burning through electricity, dedicated entirely to serving requests from existing models. A one-bit model below ten billion parameters runs on a standard CPU with no GPU required. The infrastructure built to serve users becomes available for training, and training is where new capabilities actually come from. The efficiency of the current generation directly funds the development of the next. Better models need less to run. The cycle compounds.

The Same Phone. A Different Architecture.

Even for models large enough to always require GPU infrastructure, the memory reduction changes the economics substantially. A ten trillion parameter model at full precision would require memory distributed across an infrastructure investment that only a small number of organizations globally could consider. At one-bit, the same model needs a fraction of that. The scale of what is buildable expands without a proportional increase in what it costs to build.

On current CPU hardware, running one-bit models reduces energy consumption by 55 to 80 percent compared to standard inference, a figure that has been measured rather than estimated. The reason is that in modern AI inference, moving data through memory consumes more energy than the computation itself. One-bit models move approximately ten times less data, and the energy cost falls accordingly.

Training remains on GPU hardware today because the optimizer requires higher numerical precision to function correctly. But the forward and backward passes through the network, where the large majority of training compute is actually spent, consist of matrix multiplications. On hardware designed specifically for the arithmetic of plus one, minus one, and zero, these operations require more than seventy times less energy per calculation than floating point equivalents. When dedicated hardware of this kind exists, training a frontier model will not become modestly cheaper. It will become accessible to people and institutions for whom it is currently unthinkable.

Today, every AI product routes its intelligence through an API priced for a market most of the world does not live in. The cost per query that is negligible for a San Francisco startup is ruinous for a product built for users in Nagpur or Nairobi. Local inference removes that ceiling entirely. The cost of a query is now the cost of running the user’s own device, which is already paid. A category of products that could not exist at current API prices becomes possible.

A hospital in a small city holds years of patient records, diagnostic histories, and treatment data. Using a cloud-based AI system to reason over this data requires sending it to a remote server. The records travel to infrastructure the hospital did not build, cannot inspect, and does not control. The legal and ethical responsibility for that data becomes complicated the moment it leaves the building.

A one-bit model running on the hospital’s own hardware changes this completely. The records stay in the building. The reasoning happens on machines the hospital owns. Nothing is transmitted and nothing is exposed. The protection is not a contractual commitment from a vendor. It is a physical fact.

This principle extends beyond the hospital. We are entering the age of personal robotics, of intelligent systems that will live in homes, assist in surgeries, operate alongside people in factories. Every robot that depends on cloud inference to function is not an assistant. It is a surveillance device. Every sound it hears, every object it sees, every movement it tracks, travels to a server somewhere before a decision comes back. A robot that cannot think for itself sends everything it perceives to someone else before it acts. That is the definition of surveillance, regardless of what the terms of service say. A one-bit model running on the robot’s own processor changes this completely. The perception, the reasoning, the decision, all of it happens on the device. The intelligence is present and local, answerable only to the person it serves.

Surveillance vs Sovereignty

This is what sovereign AI means in practice. Intelligence that belongs to whoever runs it, answerable to no external infrastructure, requiring no ongoing permission from any provider. Not a privacy feature. A different architecture.

India

There are moments in the history of technology when the ground shifts and everything built on the old ground becomes, not immediately but irreversibly, the past. These moments do not announce themselves. They are only obvious afterward, when the people who moved during them had already built, and the people who waited are left explaining why they waited.

India has been on the wrong side of that line before. Not because of any failure of intelligence or ambition. Because the infrastructure required to build foundational technology, the capital, the compute, the institutional depth, was somewhere else. The software services industry that India built is one of the great industrial achievements of the last thirty years. But services are built on top of foundations that others laid. That is the honest history.

This moment is different in a way that is difficult to fully absorb. The foundational layer of on-device AI does not require a data center. It does not require a hundred million dollars of compute. It requires a deep understanding of an architecture new enough that no one has a twenty year head start, and the willingness to build for the user the rest of the world’s AI industry has not built for, which turns out to be most of the world. India has the most concentrated population of that user on earth. A billion people holding phones with sufficient memory and processing power, for whom no one has yet built the intelligence that device could run. A farmer in Vidarbha who can describe what is wrong with his crop in Marathi, has a phone in his hand, and has no way to ask anyone who can tell him how to solve it. The constraint is not the person.

This will be hard. Genuinely hard. Building at the frontier of a new architecture, for users every benchmark has ignored, without the institutional support that exists elsewhere. The alternative is a scaling race that has already hit a physical wall.

After Moore

Gordon Moore made an observation about a doubling. That doubling ran for sixty years and produced the most consequential technological era in human history. It is ending now, not because the people building chips failed, but because the atom does not shrink on request.

What it leaves behind is a question that the doubling made it possible to ignore: can intelligence be built to reach everyone, or only the people with access to what it currently requires? The architecture this essay describes is the first real answer to that question. A model that, at the scales where it has been rigorously tested, performs within close margin of full precision equivalents. That runs on the hardware most people already hold. That protects everything it knows about the person using it. That costs nothing to access.