GPUs Get Slower Under Load. Living Compute Changes Under Load.

Part 1: An Agent Workload Study with a Digital Twin of Living Neural Tissue

This is the first article in a series, and it reports a working prototype built on a software digital twin together with the research question it raises, without presenting measurements from living tissue. The twin was reshaped once already, when recordings of real organoids showed that my first model had the wrong picture of how tissue declines, and I describe that correction below. Part 2 will report the analysis of those recordings in its own right.

Abstract

I built a small lab experiment in which software agents with a conventional retry policy sent classification requests through a single gateway to two very different backends. One was a simulated GPU inference service, and the other was a digital twin of living neural tissue on a microelectrode array (MEA). The twin models stimulation, evoked spiking and, for each organoid on the array, a remaining life that rest does not return. That life drains with time alone, as it does in recordings of real organoids, and, by assumption, with every stimulation pulse. A simple readout then turns the twin's spikes into classifications for the agents. Without protection, three agents completed 111 classifications in 45 seconds at 59% accuracy and spent about 13% of the tissue's remaining life doing it. When the gateway enforced a 2.5 second interval between stimulations of the same array and answered early requests with HTTP 429 and a Retry-After header, the same agents completed 12 classifications and spent under 2%. The interval did not make an answer cheaper, since each classification cost a similar number of pulses either way, and twelve classifications are too few to say whether it made answers better. What it changed was the pace at which a finite, shared substrate was used up, and who had decided that pace. All of these figures are outputs of a deliberately simplified software model, so this first part offers a prototype and a question rather than evidence about living tissue.

Introduction

Across my career as a network architect, security engineer, software developer and AI builder, compute has had a reassuring property, which is that it does not care how often it is asked to do something. Send a GPU one request or a thousand and the infrastructure problem changes shape, with longer queues, rising latency, exhausted memory and higher power draw, until requests are throttled or dropped. The accelerator still computes the thousandth request exactly as it computed the first, and much of our scheduling practice quietly depends on that property.

Living neural tissue does not share that property, because its response to a stimulus depends partly on what has been done to it recently. Neurons adapt to repeated input and can reorganize their connections, and those history dependent dynamics are what make biological networks computationally interesting. If such tissue ever sits behind an API, a request stops being a pure consumer of capacity and becomes something that can change the system serving it, which matters more now that the callers are increasingly autonomous agents.

The figure above summarizes the distinction that motivated this study. With conventional compute, load affects how long a caller waits but not what the caller receives. With living compute, every request is also a stimulation, and the state it leaves behind shapes how the tissue responds to whatever arrives next.

Background

Brain organoids are small cultures of neurons and other neural cells, grown in three dimensions from stem cells. When an organoid sits on a microelectrode array (MEA), electrical stimulation can be delivered through selected electrodes and the resulting activity recorded across the array as spikes. The interface starts to look computational, since an input is encoded as a stimulation pattern, transformed by the tissue's neural dynamics, and recovered as spikes that software converts into a digital readout.

Smirnova et al. (2023) describe organoid intelligence, or OI, as a research program aimed at developing biocomputing with brain organoids. Its goal is to study whether biological neural networks can become useful computational substrates, not to build a miniature brain. One practical route is reservoir computing, in which a fixed nonlinear system projects inputs into a rich internal state and only a simple readout is trained. Cai et al. (2023) demonstrated this with Brainoware, a brain organoid on a high density multielectrode array that served as the reservoir for speech recognition and for predicting a nonlinear equation.

It is worth stating plainly that current organoid computing runs tiny research workloads and is not a competitor to GPUs today. Operational characteristics make a more useful comparison, because a GPU is engineered to be reproducible and interchangeable within a pool. A biological network is stateful instead, and its behavior depends partly on its own history, so a scheduler has no basis for treating two pieces of tissue as interchangeable members of one pool.

Research Question

Published work already addresses whether organoids can compute, so that was not my question. I wanted to know what happens to infrastructure assumptions when the thing behind the API is alive, and specifically when AI agents with ordinary retry behavior sit in front of it. Against conventional compute a retry costs only latency and some accelerator time, but against a stateful substrate it might alter the resource that produces the answer. Framed as an experiment, the question is whether agent retries create a feedback loop that degrades correctness as well as latency. If they do, a second question is whether a mechanism in the request path, rather than in each agent, can interrupt that loop. I also wanted to see which signals a scheduler would need to manage such a backend safely.

Method

No living tissue was used at any point in this study. I built a software digital twin of the biological side, placed a simulated GPU inference service beside it, and put one gateway in front of both. To an agent the two backends were simply different kinds of compute behind one address, while to the gateway they were not alike at all.

The Digital Twin

The twin simulates two microelectrode arrays, each carrying four organoids with eight electrodes apiece, for 32 recording channels per array, 16 of which can be stimulated through a 16 position trigger pattern. My first version treated an array as one uniform piece of tissue that tired within seconds and recovered with rest. Recordings of real organoids, shared with me for this work, did not look like that, and I rebuilt the model around the trends they did show. I report those trends here only in qualitative form, and no figure in this article comes from those recordings.

In the rebuilt twin each organoid has a life of its own. That life drains with time and, in the twin, with every stimulation pulse, at a pace that differs between organoids, and when it falls low enough the organoid goes silent and stays silent, and rest does not return it. The recordings show that elapsed time alone is enough, because tissue declined, and organoids fell silent, through long stretches with no stimulation at all. Whether stimulation adds to that decline they could not settle, since the tissue that was stimulated far more also differed in age, temperature and care. The twin therefore ages with time and also charges life for every pulse, and I treat that per pulse charge as a modeling choice rather than a finding. The pace is compressed so that a trend which takes real tissue days is visible within a lab session. Electrodes are very unequal, with well under half of them lively, some firing rarely and about a third recording nothing but artifact, and spontaneous firing comes in bursts that a whole organoid shares, rather than evenly. A stimulated electrode drives only other electrodes of its own organoid, so nothing propagates between organoids, and that fixed wiring acts as the reservoir because different inputs excite different channel combinations. Evoked spike counts are Poisson distributed with a mean that scales with the organoid's remaining life. In the twin the evoked response fades faster than spontaneous firing does, which one tissue showed and another did not. At the stimulation settings the lab uses, every pulse also leaves an artifact on all 32 channels for about ten milliseconds, and many of those artifacts are small, so a reader that filters by amplitude alone fails and the first ten milliseconds have to be discarded. With gentler stimulation real tissue showed far less artifact, and the twin scales it accordingly.

Two things in the twin are kinder than the tissue it imitates, and both exist so that a lab can be built on it. Its evoked responses are far clearer than real ones, clear enough for a simple readout to work, and it keeps a mild tiredness that rest does relieve, with a 20 second time constant. The recordings give that only modest support, a small dip in the response when stimulations follow each other within a few tenths of a second, and none at intervals of several seconds. A pulse above 20 microamperes removes a large share of an organoid's remaining life at once, which models damage and for which I have no data at all. These magnitudes are illustrative, and only the direction of each effect is meant to be realistic.

Task, Readout and Agents

The task was to recognize four shapes drawn on a 4 by 4 grid, which maps directly onto the trigger pattern, so each lit cell fires one electrode with a fixed biphasic pulse of 5 microamperes. The readout counts spikes per channel from 10 to 200 milliseconds after the stimulus, discards artifacts and subtracts spontaneous baseline activity. A nearest centroid rule on cosine similarity, trained per array and checked against a negative control, then classifies the resulting vector. Chance accuracy is 25%, the trained readout names roughly two shapes in three, and confidence is the margin between the best and second best similarity scores. That is already far better than I would expect from tissue, where the same kind of readout separated stimulation patterns only modestly, and where part of the apparent separation turned out to be drift in the tissue rather than the stimulus.

Three agents ran concurrently for 45 seconds in each condition, as scripted policies rather than language models so that the runs stayed comparable. Each followed the pattern most agent frameworks encourage, choosing a shape at random, requesting a read through the gateway, and reading again, up to six attempts, whenever the margin fell below 0.08. A test harness recorded whether each final answer was correct, which neither the agents nor the gateway could see.

Conditions

In the unprotected condition the gateway forwarded every read immediately, alternating between the two arrays. In the protected condition it treated an array as ineligible until 2.5 seconds had passed since its last stimulation. When no array was eligible, it answered with HTTP 429 and a Retry-After header, and the agents waited before trying again. Among eligible arrays it preferred the most responsive one, based on an estimate from a small broker service that owned each array. That estimate was built from evoked spike yield, because living tissue has no endpoint that reports its own state, and it typically sat 10 to 20% from the true value. Reported life therefore uses the twin's internal value, which only a twin can report.

Safeguards

Three further safeguards did not affect the reported numbers but belong to the same argument about where controls should live. The gateway checked caller supplied stimulation parameters against illustrative bounds and returned a structured error naming the field and its limit, enough for an agent to correct a unit error such as 50 microamperes written for 5. Each broker disabled all stimulation when a session ended or went silent for eight seconds, so a crashed agent could not leave electrodes armed. It also kept an append only record of stimulation and cleanup in which each entry carries a hash of the previous one, which makes the record tamper evident though not tamper proof. These were infrastructure mechanisms in the experiment rather than features of any commercial platform.

Results

In the unprotected run, the three agents completed 111 classifications in 45 seconds with an accuracy of 59%, and in doing so spent about 13% of the remaining life of the organoids they stimulated, 15% on one array and 12% on the other. The agents saw only their own confidence margins, so none of them could tell which answers were the wrong ones, and nothing in the request path knew that the tissue was finite. With the 2.5 second interval enforced at the gateway, the same three agents completed 12 classifications over the same 45 second window and spent under 2% of that life. Ten of the twelve were correct, but twelve classifications are far too few to support a claim that the interval improved accuracy, and I do not make one. Over those windows the tissue received 1,248 stimulation pulses without protection and 156 with it, roughly 28 pulses per second against 3.5, while throughput fell by about a factor of nine.

Measure	Unprotected	Interval enforced
Interval between stimulations of one array	None	2.5 s
Array selection	Alternating	Most responsive eligible array
Classifications completed	111	12
Stimulation pulses delivered	1,248	156
Classification accuracy	59%	10 of 12, too few to compare
Remaining tissue life spent	about 13%	under 2%

Per completed classification the two runs used a similar number of pulses, about eleven against thirteen, so the interval did not make an answer cheaper. Every pulse spends life in this model whoever sends it and however long they waited. What the interval changed was the pace, and with it how long a shared, finite substrate lasts and who made that decision. These figures are properties of a deliberately simplified model, not biological measurements or benchmarks of any real organoid system. The direction of the difference is worth carrying forward, while its size depends on parameters I chose.

The Retry Feedback Loop

The dominant effect in the unprotected run is simply the stimulation rate, since three agents working without pause delivered pulses about eight times faster than the paced run did, and each pulse spent life. Behind it sits a slower feedback loop that emerges from two rules, one in the model and one in the agents. This study did not measure the loop's separate contribution, so what follows explains the mechanism rather than quantifying it.

As an organoid's life is spent its evoked response fades relative to the spontaneous background, and that lower signal to noise ratio narrows the margin between the best and second best class. A narrower margin falls below the confidence threshold more often, and the agent then does what it was designed to do, which is to retry and deliver more stimulation to the same tissue. Unlike tiredness, spent life does not come back, so each turn of the loop leaves the tissue permanently a little less able to answer the next request. Nothing in the twin injects this failure, and every step is locally reasonable, so the degradation appears only when the steps are composed.

Against a conventional backend a retry is a nearly harmless way to buy confidence, because the second inference runs on hardware in the same condition as the first. Against the twin, each retry spent a little of the resource that decided whether later answers would be trustworthy, and spent it for good. The failure was also quiet, since every request succeeded quickly with a well formed answer, and overload protections that watch latency and error rates would have seen nothing wrong.

Discussion

Health, History and a Different 429

Under load a GPU becomes slower, but in this experiment load used the living compute model up, which changes what the systems in front of it need to know. A scheduler such as the one in Kubernetes asks where capacity is available. A scheduler for biological compute would also have to ask which specimen is currently appropriate to stimulate, which is a question about health and history. The table below pairs familiar accelerator signals with signals a biological backend would plausibly require, although the right hand column is a hypothesis rather than a specification.

Conventional accelerator signal	Biological compute signal
Utilization	Remaining life of each organoid, and its responsiveness
Queue depth	Stimulation history
Memory headroom	Recovery since the last stimulation
Latency	Experimental protocol and its limits
Power draw	Electrode state
Equivalence across devices of one model	Variability between biological specimens

The protected run relied on an ordinary mechanism, since HTTP 429 with a Retry-After header is how many APIs already ask clients to slow down, but its meaning changed. A 429 normally tells a caller that it has consumed too much of a shared resource in some window, after which the allowance refills, but here nothing refills. The refusal says that the resource is finite, that an operator has set the pace at which it may be spent, and that this caller is ahead of that pace. That shift moves the reason for refusal from the caller's behavior to the backend's condition, and it puts the decision in the request path rather than in each agent.

Observation That Perturbs the System

Observability changed too, since a GPU's temperature, memory errors and utilization counters can be read continuously without affecting the workload, while the responsiveness of neural tissue can only be estimated by stimulating it. In the twin, better estimates required more measurements, and each measurement was itself a stimulation that spent a little of the life being measured. Our observability culture assumes measurement is cheap, with metrics scraped every few seconds and synthetic probes running around the clock. In biological compute that habit would turn the health check into part of the load it is meant to measure.

Why FLOPS, TOPS and Watts Mislead

Comparing organoids with GPUs on FLOPS, TOPS or watts is tempting, usually starting from the commonly cited estimate that the human brain runs on roughly 20 watts, but that figure does not transfer to organoid systems. An organoid depends on culture systems, environmental control, microelectrode arrays, signal acquisition and conventional computers, none of which appear in the energy budget of a brain. Current organoid systems have not been characterized well enough for a like for like comparison, so I would not claim that they are more efficient than GPUs. The more defensible claim is that the two optimize for different things, deterministic numerical throughput on one side and adaptation, plasticity and nonlinear dynamics on the other.

Heterogeneous Rather Than Replacement

For these reasons I find heterogeneous computing a more useful frame than replacement. Silicon remains exceptionally good at deterministic arithmetic and at moving large volumes of data, while biological networks may eventually prove useful for specialized adaptive tasks where their dynamics offer something silicon does not. CPUs did not disappear when GPUs arrived, nor GPUs when specialized AI accelerators arrived, so if biological computing becomes practical I expect it to join the stack as a coprocessor rather than replace it.

Agents and Physical Consequences

After building this experiment I became less interested in whether organoids will become important computers and more interested in how AI agents increasingly call systems where requests have physical consequences. A request to a GPU consumes electricity and time, while a request to a laboratory robot, an instrument or biological tissue can change something in the world, sometimes including the substrate that serves it. Agents retry and parallelize their work, which is valuable when the environment is software but risky when it is physical and stateful. The safety boundary therefore needs infrastructure between intention and execution, where policy decides whether an action is permitted and admission control and state aware scheduling decide when and where it can safely run.

In this study the gateway played that role in a narrow form, with one pacing rule and a preference for the most responsive array, and even that simple mechanism changed how fast the tissue was used up by nearly an order of magnitude. Controls inside each agent can be omitted by the next agent, whereas controls in the request path apply to every caller, which is the main lesson I took away. The same reasoning extends to any backend that remembers what was done to it.

Limitations

The most important limitation is that this study used a digital twin and no living tissue, so every figure is an output of a software model. The twin follows trends I saw in recordings of real organoids, but those recordings are few, they come from experiments designed for other purposes and without unstimulated controls, and while they establish that tissue declines with time alone, they could not tell me whether stimulation adds to it. The twin's per pulse charge is therefore an assumption, and so is its damage threshold, for which I have no data, while its mild recoverable tiredness has only modest support. Its evoked responses are much clearer than those of real tissue, so the readout's accuracy says nothing about what tissue can do. The pace of decline is compressed, the magnitudes are illustrative, and the 2.5 second interval was chosen because it suited the model. The numbers are therefore not benchmarks of organoid computing or of the gateway.

The experimental design is also small in ways that limit what the results can support. Each condition was run once with three scripted agents over 45 seconds, and the paced run completed only twelve classifications, which is why I compare pulses and life spent, which follow from the model's arithmetic, and decline to compare accuracy. The GPU backend was simulated and never performed the classification task, and the two conditions differed in both the interval and the array selection strategy, so the contribution of each change cannot be isolated. I make no claim about energy efficiency in either direction. Research with human neural tissue also raises ethical questions that are outside the scope of this study.

I should also record that this article was revised, since its first draft described a twin whose tissue tired in seconds and recovered with rest, and reported that pacing restored accuracy. The recordings supported at most a small effect of that kind, I rebuilt the model, and the result changed from one about correctness to one about how fast a finite resource is spent. Part 2 of this series will report the analysis of those recordings in its own right, with the agreement of the people who shared them: what declines and how, what a simple readout can and cannot recover from real tissue, and which questions the recordings leave open.

Conclusion

This experiment does not show that neurons are about to displace GPUs, and its twin makes no quantitative prediction about real organoids. What it does show, within the limits of a model, is that retrying agents behind a stateless request path can quietly use up a finite, stateful backend, and that nothing in a conventional request path would notice. Moving knowledge of backend state into that path did not make answers cheaper, and I cannot say that it made them better. It set the pace at which the substrate was spent, and it put that decision with an operator rather than with whichever agent retried hardest. When compute becomes biological, a request stops being only a request and becomes an intervention, and assumptions that cloud infrastructure has accumulated over decades, such as cheap retries and free health checks, would need to be reconsidered. GPUs taught us how to schedule scarce compute, and living compute may eventually teach us how to schedule scarce state, which seems to me the more interesting frontier.

References

1. Cai, H. et al. "Brain organoid reservoir computing for artificial intelligence." Nature Electronics, 2023.
2. Smirnova, L. et al. "Organoid intelligence (OI): the new frontier in biocomputing and intelligence-in-a-dish." Frontiers in Science, 2023.

---

This study used a software digital twin and no living tissue at any stage. No commercial platform was evaluated, and every figure is the output of a simplified model rather than a biological measurement. The twin's behavior follows trends in recordings of real organoids shared by FinalSpark, whom I thank, and no figure from those recordings appears here. Part 2 of this series will report the analysis of those recordings.