A BrainChip AKD1500 in our racks spent this week teaching itself to tell things apart. That was the first step for what follows after the LLM/CUDA work I did last week. Nobody labelled anything for it. Nobody trained it, in the way that word is normally used.
That is worth pausing on, because it is not how any of this usually works.
Modern AI learns from examples that a human being has already sorted. Behind every image model is an enormous pile of pictures that people were paid to tag, one at a time. The machine then spends days or weeks in a data center adjusting billions of internal numbers, nudging each one a fraction at a time until its answers line up with the tags. It works, and it is enormously expensive, and that expense is a large part of why this industry looks the way it does.
The chip did none of that. It watched, and it sorted, in a single pass, while it was running.
The rule it used was designed by Peter van der Made about twenty years ago, and it is running on the silicon he built for it. It works in a way that has no real equivalent in ordinary AI. In a normal network, learning means connections grow stronger or weaker, numbers drifting up and down forever. Here, a neuron has a fixed number of connections and can only ever REARRANGE them. When a neuron responds to something, the connections that were plugged in but stayed quiet trade places with the ones that were unplugged but would have fired. Picture an old telephone switchboard: the operator moves cables between sockets all day, but there are never more cables than the board came with.
That sounds like a limitation. It is closer to the opposite. Because nothing accumulates, the chip’s memory and power do not creep upward as it learns, so it can keep learning while it works instead of stopping to be retrained.
It also makes the design checkable in a way that is genuinely rare here, because it is a promise about a physical quantity. If the rule is real, the number of live connections can never change. So I counted. Before learning: 35,584. After: 35,584. In between, more than sixty thousand individual connections had moved. Learning happened, and nothing was added.
Then the question that matters. Does it work?
I gave it photographs of eight kinds of vehicle, with no labels of any kind. It sorted them into groups by itself, and those groups matched what a person would have called them about ninety five percent of the time. I showed it three kinds of vehicle it had never encountered, and it did BETTER than a conventional classifier that was handed the labels.
Every run was checked against an identical copy of itself with the learning switched off, measuring learning rather than luck. The learning version won every single time.
The last test is the one that convinced me. I froze it. Not one setting changed. Then I pointed it at things that had nothing to do with vehicles: weather satellite images, photographs of rail cars, and sound. It handled all three, including the sound, using a network that had only ever been shown pictures.
A visual network, listening.
It transfers. Not tuned per dataset. Transferred.
Those three results are not ranked the way the percentages make them look, and the correction runs the opposite way from the usual sales pitch. Guessing at random gets you 33 percent on the weather task and 11 percent on rail cars, so the rail car number is nearly six times better than chance while the weather number is under three times better. The lowest score is the strongest result. The audio number is the honest weak point: it is a two-way choice, so chance is 50 percent, and 82.4 is less than twice that, which is about what a network built for pictures deserves when you ask it about sound.
What moves those numbers is not how much data there was. I tested that directly, with two and a half times the examples, and it changed nothing, even though the same extra data made a conventional labelled classifier measurably better. What moves them is how many categories you are asking for, and how much the frozen network already knew about that kind of thing.
For anyone who wants the exact figures rather than the shape of it: eight classes at 94.9 percent where chance is 12.5, three never-trained classes at 88.0, and the frozen transfers at 98.4 percent on weather satellite across three classes, 82.4 on audio across two, and 66.3 across nine classes of rail car. The control comparison was 80 runs out of 80. I can find no public numbers for this mode on this part, so these are mine.
Here is the part many people will skip past and it is the whole thing: NONE OF THIS IS A SINGLE CHIP.
The result comes from ten chips learning at once and the fleet is not a speed trick. Each chip initializes its own weights on device, so ten chips converge on ten genuinely different partitions of the same data. Their disagreement is information. Combining them beats a matched neuron budget at every point measured: five codebooks of 1024 units beat any single layer of any size we could build. You cannot buy this with a bigger chip, it only exists because there are many of them and something is coordinating them.
That something is orchestration and we did not have to invent it. Ten nodes share one GPFS filesystem, so every chip sees the same tree and a single write serves the fleet. Above that sits IBM Spectrum Symphony which we have already used to schedule Akida work at a scale nobody else has: a single workload cascading across three data centers, Dallas to Pittsburgh to Washington DC, 120,000 requests, exact counts, zero drift. Every matmul of a distilled language model landed on a different physical host.
Neuromorphic computing has spent a decade as a single chip beside a single sensor. The interesting unit was never just the chip, it is the fleet.
Which brings me to memory and to the thing that is easy to get wrong about it.
Every AKD1500 boots asking for 16 MB of host memory and is granted four. That is five layers of software conservatism, four of them ours to fix: a kernel shipped with the Contiguous Memory Allocator compiled out, a driver capping its own request with a define, and an SDK carrying a hard-coded ceiling that never once asked the driver what it actually got. Turn CMA on, raise the constant, patch the SDK, and the chip addresses its entire documented PCIe window. 4 MiB to 768 MB. 192 times the stock allocation, verified exact, now deployed across all ten chips.
Here is what that does NOT buy: more cortex. I built a three area cortical hierarchy across three chips on three hosts, learning on chip, at 100 percent. It uses none of the window. The areas live in on-chip SRAM and the spikes between them are kilobytes. That entire structure would run on a stock part.
What the window buys is time.
Akida 1.0 has no temporal processors. No on-chip provision for state across frames. Any task whose answer depends on ORDER is therefore unreachable from a single frame and the history has to live somewhere the chip can address. That is the window and the effect is not subtle. On ordered symbol pairs, seeing only the current frame gives 54.2 percent, which is exactly what one frame permits. Reading one frame of the past out of the window gives 100 percent. The difference is the memory.
The capacity then is the whole point. A stock 4 MiB window holds 16,384 frames of history. At 10 Hz that is 27 minutes. 768 MB holds 6.3 million frames, which is seven days. Across the fleet, that adds up to 110 days of continuous experience.
I ran it. A symbol from one million frames ago, recalled out of 122 MB of history and classified correctly on chip, Hebbian, no backprop. The stock configuration loses that history thirty times earlier.
The silicon fixes how much cortex you get. 480 neural processors across our fleet, and no software changes that number. What a fixed sheet of cortex can DO is bounded by how far back it can remember and that was the part being left on the floor.
So: a chip that learns without labels, in a single pass, while it runs. Ten of them coordinated by a scheduler that already moves work between datacenters. Each one able to reach back a week.
That belongs in a rack, scheduled next to the GPUs as a peer. Not bolted to a camera.
And once it is in a rack, a week stops being the limit.
The window is what a chip can ADDRESS. It is not what a chip can remember. Behind it sits the same GPFS filesystem the fleet already shares, and that filesystem is already tiered: three storage pools with a policy engine live on them today. The free space alone holds centuries of frames at the rate the chips produce them.
What makes it memory rather than a log is that GPFS already retrieves by policy. An ILM rule on GPFS selects on attributes and moves data between pools, so with the right tags a policy rule IS a content addressed query, prefetch and recall already ship as options, machinery that has been running quietly in banks, national laboratories, and tons of other enterprises for decades. The codebooks even supply their own retrieval cue. They emit a novelty score, 0.930 AUROC on first encounter, which is exactly the signal that says the current input is not in the working set and something should be fetched.
Then IBM Spectrum Archive extends that same filesystem onto tape, through LTFS, as simply another storage pool, and a TS4500 library scales it into the hundreds of petabytes.
The memory behind a neuromorphic chip turns out to be GPFS and Spectrum Archive doing exactly what they already do for every other kind of data in the building. At that point you stop choosing what is worth keeping. You record continuously and recall selectively, and everything the fleet ever perceived stays addressable, for inference now and for proving what a machine saw and when, years later.
The learning rule is Peter van der Made’s and it is twenty years old. What was missing was never the neuroscience.
And it is not only the rule that has been waiting. GPFS shipped in 1998, which makes the filesystem older than the learning rule it is now holding memory for. Tape has been the archive of record since the 1950s and the policy engine that decides what comes back off it has been in production for as long as most people reading this have been working.
So, none of these pieces are new. They have simply spent thirty years in different buildings, owned by different industries, described in different vocabularies. Neuromorphic computing sat next to a camera. Enterprise storage sat in a data center. Nobody put them in the same room.
That is the whole of what changed here. Not the neuroscience and not the storage. Memory, orchestration, and enough chips in one place to make the fleet the unit of computation. Ten chips is just the beginning.
Run Akida anywhere. Run Akida everywhere.