Mimetic Computing
The Future of Computation is more Mime than Reason
Imitation is the Highest form of (Computational) Flattery
We are in the middle of a quiet expansion in what computation can look like. For most of the last eighty years, the answer was settled: decouple logic from physics, treat the transistor as an interchangeable commodity, and scale. That abstraction gave us portability, programmability, and the digital revolution, and it is not going anywhere—it is simply gaining company. In quantum systems, neuromorphic devices, and analog inference engines, approaches are maturing for problems that do not decompose cleanly into discrete steps.
This matters because the frontier of useful computation is shifting. Quantum simulation, real-time morphological control, and high-dimensional optimization resist divide-and-conquer. Symbolic and heuristic methods for dynamic, tightly-coupled systems have stalled. We lack scalable first-principles approaches to turbulence, ontogeny, or many-body quantum dynamics; forcing these phenomena into discrete boxes averages away the very coupling we need to study. When a problem’s structure is inseparable from its physics, the choice of substrate becomes part of the algorithm. Recognizing which regime a problem belongs in is becoming as important as the algorithm itself.
Look at what a transistor actually does. It does not think. It dissipates energy along a path of least resistance, and we have arranged billions of these switches so that their collective pattern maps onto Boolean logic. The symbols ride atop the physics; they do not replace it. This arrangement was a triumph—it is what let us scale without micromanaging thermodynamics. But every abstraction has a boundary. In substrates where noise and continuous dynamics are raw material rather than something to suppress, forcing every problem through a Boolean layer before it touches hardware becomes the bottleneck itself.
Not all knowledge is propositional, and not all computation is symbolic. Some truths are better found through enaction than through derivation.
Conventional computing fractures a problem into discrete tokens, executes sequential operations, and reassembles the answer. Some natural systems resist that cartography. The dynamics of a living cell are defined by couplings that cannot be truncated without destroying the phenomenon. A small error at one scale propagates through relational structure, amplifies at the next coupling, and re-enters as a corrupted boundary condition for every neighbor. Rather than accumulating linearly as they do in decomposable systems, errors compound through the topology of the problem itself.
A brief history...
Before digital machines, analog computers solved differential equations by letting voltage and current be the variables. A differential analyzer did not calculate a projectile’s trajectory; it was the trajectory, in electrical form. Wind tunnels do not solve Navier-Stokes symbolically—they let air be air around a shape. Such work seeded cybernetics: analog physical computation, real-time feedback, and the recognition that loop structure, not symbol manipulation, is a deeper primitive in certain contexts. Cybernetics explained how systems self-regulate. It did not fully answer which substrate to use, or why the choice matters. That required a second insight: mimetics.
Reservoir computing inherits from both traditions. It treats the choice of substrate as a strategic variable: instead of routing every calculation through a generic symbol layer, choose a material whose native dynamics mimic the problem itself.
In 2003, Fernando and Sojakka demonstrated Pattern Recognition in a Bucket. They asked whether a trainable recurrent network truly required a fixed lattice of nodes. Their answer: no—it literally could just be a bucket of water. Vibrating the surface with LEGO-mounted motors at input frequencies, they showed that, for their task, the water’s native physics was the computation. These methods belong to a larger class of computing, known as reservoir computing (RC).
Other examples use have used lasers, memristor networks, fluid tanks, and photonic delay lines as analog feature extractors, letting real dynamics stand in for learned ones. The repretour of substrates is seemingly endless and expanding. The field has further branched into neuromorphic computing, morphological computing, and some forms of quantum computing. Classical computing offers precision and programmability by insulating logic from physics; which can be an immense advantage when the problem admits clean decomposition. By contrast, RC offers leverage by aligning the problem with the physics, and typically at a fraction of the energy cost, since the computation is folded into physical evolution rather than layered on top of it.
Technology is expanding our ability to recognize which regime we are in, choose the right substrate, and design with the full range of physical affordances across materials—rather than forcing every problem through a single abstraction. In practice, that means identifying a physical system’s state-space, imposing constraints, and reading the final configuration as the answer. The strategy is simple: match energy landscapes, not symbolic ones.
There is something humbling in this. Patterns in nature recur across scales: river deltas branch like pulmonary vasculature; drumhead eigenmodes rhyme with atomic orbitals; vortex streets echo galactic spiral arms. The core intuition of computational mimicry is to find a system whose generative dynamics map isomorphically to another, and then coax nature’s patterns toward a question we care about. Fundamentally, it is an act of alignment. That alignment is already sorting the field: organizations expanding their substrate toolkit are tackling problem spaces which were inaccessible to those working purely within the classical stack.
The LLM Flywheel
Why is RC becoming a thing now?
Two years ago, reservoir computing occupied a narrow corridor: theoretically elegant, experimentally fragile, practically confined to a handful of academic groups. Neuromorphic chips had no software ecosystem. Building a new analog reservoir meant months of hand-tuning before a single experiment could run.
What’s changed is not a breakthrough in analog physics, but the re-purposing of large language models into general research infrastructure. They are no longer just text generators; they are compression engines for the iteration cycle of applied science. An RC researcher today can:
Synthesize and triangulate literature across decades of disciplinary silos in minutes rather than months, surfacing non-obvious substrate–phenomena couplings that keyword searches routinely miss.
Generate and debug simulation code, CAD layouts, and control scripts without waiting for scarce specialist bandwidth, collapsing the lag between an idea and a testable geometry.
Translate concepts across domains—say, from probabilistic inference in spin-glass models to photonic reservoir design—lowering the activation energy for insights that straddle specialties.
Parse unstructured lab data by cleaning, labeling, and extracting structure from instrument logs and handwritten notes that would otherwise sit in preprocessing queues.
When a researcher can traverse ten design variations in the time it once took to build one, the accessible space of reservoir geometries and training protocols expands by an order of magnitude.
But the deeper flywheel is mathematical, not bureaucratic. The conceptual scaffolding that underpins modern LLMs—high-dimensional linear algebra, probabilistic inference over graphical structures, dynamical systems theory—is precisely the vocabulary now used to characterize reservoir and quantum computing. As that mathematics has been stress-tested at billion-parameter scale, it has become a common technical substrate. Former complex research dialects are now becoming legible to practitioners using shared software idioms. Published advances in training dynamics are embedded in LLMs and migrate back into how we understand, design and refine new physical reservoirs.
That shared vocabulary is also making the cost of enforced determinism quantifiable. Consider quantum error correction. Because measuring a qubit directly collapses its state, gate-based quantum computing preserves strict digital logic by inferring errors indirectly—sampling high-dimensional parity-check patterns from neighboring ancilla qubits to compute a syndrome.
That syndrome is then decoded classically to diagnose whether and where an error occurred, all without ever learning the qubit’s actual value. It is a brilliant workaround.
This example captures the essence of what might be called a ‘determinism tax’. Thousands of physical qubits and dedicated classical decode hardware are required for every reliable logical qubit, and the overhead steepens as the system scales. Forcing a naturally noisy, continuous, coupled physical system to behave like a discrete symbol manipulator does not always scale. There are regimes where the correction apparatus becomes slower and more costly than the computation it protects.
This is why the question is no longer whether these substrates can compute, but which architectural commitments will realistically survive signal-to-noise budgets and which will buckle under them.
The Systems Pattern
For the foreseeable future, I believe that companies who most elegantly delay, bypass, or redefine the need for high-overhead massive-scale syndrome decoding will prove the most architecturally resilient. And this connects directly to how mimetic computational methods have increasingly become a strategic asset rather than a cumbersome liability.
The industry bottleneck: the signal-to-noise ratio.
The winners will not be those who simply build the largest quantum computer, but those who manage this ratio most elegantly. Three strategies are emerging:
Change the geometry of the signal. Microsoft’s topological approach encodes information in global, non-local degrees of freedom—braiding effective Majorana modes—so that local perturbations cannot touch the logical state. By hardening the information itself, they bypass the standard syndrome-decoding arms race.
Amplify the signal so noise matters less for longer. IonQ and Quantinuum’s trapped-ion platforms achieve gate fidelities and coherence times far above the solid-state baseline. The signal stays clean enough that deep algorithms finish before massive QEC overhead dominates, effectively delaying the syndrome cliff.
Change the question so noise becomes a feature, not a bug. D-Wave’s annealing approach does not digitize the problem into gates at all. It maps an optimization landscape onto a physical Hamiltonian and lets thermal and quantum fluctuations drive the search. There is no syndrome to decode because the computation is the system’s natural evolution toward low-energy states.
These strategies sit along a spectrum from natural dynamics to enforced determinism. At one pole, reservoir and analog methods leverage continuous, high-dimensional physics and read the equilibrium state as the answer. At the other, conventional computation forces nature into strict, deterministic, clocked binary gates. Every quantum program lands somewhere between control and leverage.
Companies relying purely on brute-forcing standard QEC on noisy hardware face the highest risk of being outpaced by these more architecturally resilient approaches.
...In engineering, one must choose. Carefully.
Just Scratching the Surface
This is not a comprehensive survey. Nor is it an absolute stance. The point is to mark the poles of a design space: forced determinism at one end, recruited natural dynamics at the other. Most real-world systems will live somewhere in-between. Architectural choices made in the next few years are not neutral. They will lock in what classes of problems remain reachable, and which ones become prohibitively expensive.
Committing to brute-force syndrome decoding on inherently noisy hardware, for instance, contracts the frontier to whatever fits inside an error-correction budget. Committing to topological protection, trapped-ion coherence, or native analog dynamics expands it to problems where the substrate itself does part of the work. These are strategic industrial decisions as much as scientific ones, and they tend to harden quickly once capital and talent are allocated.
In the next article, we will delve further into architectures between these poles: hybrid digital-analog training protocols, coherent Ising machines for combinatorial optimization, and the software abstractions finally making neuromorphic chips programmable. Emphasis will be placed on the crossover where these systems stop being laboratory demonstrations and start absorbing production workloads—where the signal-to-noise budget is tight enough to matter, but the substrate is cooperative enough to deliver.
This is not investing advice.
Stay Curious.
—Postscript —
I have been researching Reservoir Computing for over 10 years. It was such a revelation when I first encountered it. So beautiful in it’s apparent simplicity. I often wondered how, when, and whether it could be more widely used in industry. It’s nice to see the field (finally) come to fruition; and getting the attention it deserves. I don’t see a lot of cogent publications on this topic which are written for a general audience. So I thought it was high-time I wrote my own.