When John von Neumann wrote the EDVAC report in 1945, he was solving a practical problem: how to build a computer that could change its program without being physically rewired. He was not thinking about artificial intelligence. The term would not be coined until 1956. Neural networks were a theoretical curiosity. Machine learning did not exist. The tasks von Neumann had in mind were ballistic calculations, weather prediction, and nuclear weapons simulations.
Yet the architecture he described, the stored-program computer, turned out to be the essential precondition for artificial intelligence. Every AI system running today, every large language model, every image classifier, every autonomous vehicle controller, runs on hardware that follows the basic design von Neumann outlined eighty years ago. This is not a coincidence. There are specific features of the EDVAC architecture that make AI possible, and understanding them illuminates both the power and the limitations of modern AI.
Why the Stored Program Matters for AI
Before the stored-program concept, computers were programmed by physically reconfiguring their hardware. ENIAC required operators to reconnect cables and reset switches for each new problem. This meant that the computer’s behavior was fixed by its physical configuration. It could not modify its own program, could not learn from data, and could not adapt to new situations without human intervention.
The stored-program architecture changed this fundamentally. By placing the program in the same memory as the data, von Neumann created a machine that could:
- Treat programs as data: A program stored in memory can be read, modified, and rewritten by another program. This self-referential capability is essential for AI systems that improve their own performance.
- Execute arbitrary instructions: Any computable function can be expressed as a sequence of instructions stored in memory. The machine is not limited to a fixed set of operations. It can do anything that can be expressed as an algorithm.
- Modify its own behavior: A program that adjusts its parameters based on data (the core of machine learning) is a program that modifies itself. This requires the ability to write to the same memory that holds the program, which is exactly what the stored-program architecture provides.
These properties are not optional extras. They are the minimum requirements for a general-purpose learning system. Without stored programs, there is no machine learning. Without machine learning, there is no modern AI.
From Logic Gates to Neural Networks
The connection between von Neumann’s architecture and neural networks is deeper than it might appear. In 1943, four years before the EDVAC report, Warren McCulloch and Walter Pitts published a paper showing that networks of simple computing elements (modeled on biological neurons) could compute any logical function. Their “neural networks” were abstract: mathematical models, not physical devices.
Von Neumann was aware of McCulloch and Pitts’s work. The EDVAC report explicitly draws analogies between the computer’s components and neurons, comparing the vacuum tubes in the computer to the nerve cells in the brain. Von Neumann saw the stored-program computer and the neural network as two different implementations of the same underlying principle: computation through networks of simple switching elements.
Modern neural networks (the deep learning systems behind ChatGPT, image recognition, and AlphaFold) are, at the hardware level, programs running on von Neumann machines. The “neurons” in a deep learning model are not physical components. They are mathematical functions (multiply inputs by weights, sum, apply a nonlinear activation) computed by the processor and stored in memory. Training the network (adjusting the weights to improve performance) is a process of writing new values to the same memory that stores the program. This is the stored-program concept in action: the machine modifies its own data (the weights) to improve its own behavior (the accuracy of its predictions).
Memory: The Bottleneck and the Enabler
Von Neumann’s design placed programs and data in a single, unified memory accessed through a single channel (the memory bus). This creates what is known as the von Neumann bottleneck: the processor can only read or write one piece of data at a time, and it must share the memory channel between fetching instructions and fetching data. For conventional programs, this is usually not a serious limitation. For AI, it is the central performance challenge.
A modern large language model has billions of parameters (weights), all of which must be read from memory, multiplied by input values, and summed during each computation. The processor is fast enough to perform the arithmetic, but reading billions of weights from memory takes time. The memory bus becomes the limiting factor, not the processor speed.
This is why modern AI hardware (GPUs, TPUs, and specialized AI accelerators) modifies the von Neumann design by adding massive parallelism and localized memory. A GPU contains thousands of simple processing cores, each with its own small memory, allowing thousands of multiply-add operations to proceed simultaneously. This is a variation on the von Neumann architecture, not a replacement. The basic principles (stored program, fetch-execute cycle, data and instructions in memory) remain the same. The modification is to provide many parallel paths between processors and memory, reducing the bottleneck.
The Universality Argument
The deepest connection between the EDVAC architecture and AI is the concept of universality. Alan Turing proved in 1936 that a single machine (the universal Turing machine) can simulate any other computing machine, given the right program. Von Neumann’s stored-program computer is a physical realization of this idea: a single piece of hardware that can perform any computation by loading the appropriate software.
This universality is what makes AI possible on general-purpose hardware. You do not need to build a special “intelligence machine” to run an AI system. Any stored-program computer, given enough memory and processing speed, can simulate any neural network, execute any learning algorithm, and (in principle) replicate any information-processing behavior, including the behavior we call intelligence.
Whether a von Neumann machine can replicate all aspects of human intelligence is an open question. Some researchers argue that consciousness, creativity, and understanding require something beyond computation. Others argue that the brain is itself a computing device (albeit a very different one from a von Neumann machine) and that sufficiently powerful computation can replicate any brain function. This debate, which began with Turing’s 1950 paper on machine intelligence, remains unresolved.
What is not debatable is that the stored-program architecture provides the platform on which modern AI has been built. Von Neumann did not foresee ChatGPT, self-driving cars, or AlphaFold. But the architecture he described, with its stored programs, its unified memory, and its universal computational capability, is the reason these systems exist. The 101-page report he wrote in 1945 did not just define how computers work. It defined the substrate on which artificial intelligence would eventually emerge.
What Comes After Von Neumann?
The von Neumann architecture has served AI well, but the demands of modern AI systems are pushing it to its limits. The von Neumann bottleneck, the energy cost of moving data between memory and processor, and the fundamental mismatch between the serial fetch-execute cycle and the massively parallel operations of neural networks are driving the search for alternative architectures.
Neuromorphic computing aims to build hardware that mimics the brain’s architecture directly, with processing and memory integrated in the same physical location (as in biological neurons). Quantum computing exploits quantum mechanical phenomena to perform certain computations exponentially faster than any classical machine. In-memory computing performs calculations directly in the memory chips, eliminating the need to move data to a separate processor.
None of these alternatives has yet replaced the von Neumann architecture for general-purpose computing. The stored-program computer remains the dominant paradigm, as it has been since 1945. But the trajectory of AI suggests that some form of architectural innovation will eventually be necessary. When that innovation arrives, it will be the first fundamental departure from the design that von Neumann sketched on those 101 pages. Until then, every artificial intelligence in the world runs on a machine that a mathematician described in a wartime memo, never imagining what his architecture would one day be asked to do.
No products in the cart. 