Great enterprise architecture has always come down to one thing: putting the right technology against the right problem. Real problems are rarely one shape. They mix control, reasoning, memory, and sensing. Each part is solved best by a different kind of compute. Neuromorphic is now one of those kinds, ready for the enterprise today, even on commodity hosts. So the interesting question is not whether neuromorphic belongs in the enterprise. It does. The question is where the new intelligence should live and what we should call that layer because the name we give a layer quietly decides the architecture we build around it. Call something an operating system and you will start designing as though it owns the machine. Most of the time it doesn’t and shouldn’t. So I want to lay out how I think about that layer and why I use the language of a heterogeneous compute ontology to describe what we’re looking at here.
The stack already has its layers
An operating system owns the hardware and exposes it to processes, schedules cores, manages memory, mediates I/O, and drives devices through kernel modules. That is not a small job and it is not a vacant one. Linux already does it and it does it well.
This is where BrainChip Akida actually enters the enterprise. An Akida M.2 or PCIe chip becomes a first-class device because a Linux kernel driver presents it as one: load the module and the chip appears as a node-local device with a uniform interface that everything above can use without caring about the silicon underneath. That abstraction is the unglamorous essential work of an OS and it is exactly why you can drop Akida into commodity hosts today almost anywhere. The operating-system slot is taken and it is earning its keep at the hardware boundary.
The capabilities that make neuromorphic exciting at scale live above one machine’s operating system. Domain learning, novelty detection, and consolidation are behaviors of models and services running on a fabric of machines that already run an OS. Naming that layer an operating system does not elevate it and places it in a slot the kernel already occupies, overlooking the real OS doing the real device work underneath.
Symphony is a service fabric
Thinking we need a neuromorphic OS can wind up treating Symphony as little more than plumbing. Symphony’s capabilities are far more than that and most people never engage half of what it offers.
Symphony is service-oriented. You write a service that expresses your business logic, what the work actually is, and Symphony takes responsibility for how that work gets done across the cluster: where instances run, how many of them, how they scale with demand, how they recover from failure, and how tenants share one pool without stepping on each other. Resource plans lend, borrow, and preempt capacity across consumers you define in line with the way you organize your business or endeavor. Preloaded services keep models hot and resident on the chips instead of cold-loading per request, which matters enormously for an accelerator like Akida where you load once and serve many or load a lot and serve more. Sessions carry state or they don’t as the application requires. Tasks are fault-tolerant, failover is automatic, redundancy easily established, and telemetry is live across a heterogeneous pool of CPUs, GPUs, and neuromorphic silicon.
That separation is the whole point and it is the opposite of what an OS does. An operating system binds processes to machine hardware. Symphony does the inverse: it frees your business logic from any particular machine or set of nodes. The service stays clean and portable, declaring what it needs and the fabric decides how and where to deliver it. That is what opens the door to immense scale. The same service definition that runs on one node runs on hundreds without rewriting your logic, because scaling is the fabric’s job, not the application’s. You don’t get that by building an operating system. You get it by refusing to and letting orchestration be orchestration.
The notion of ‘business logic’ undersells what that frees you to do. The service is not just invoicing rules or a request handler. It is whatever you actually want neuromorphic compute to be and do: organizing a set of Akida chips into a cortical substrate, standing up a software-defined event camera, running anomaly detection across a sensor field, or teaching a fabric to recognize a domain and adapt to it. And it is rarely one service. A real solution is usually several services composed together, each doing its part, wired into something larger than any one of them. You describe the solution, the behavior you are after, in the language of the problem and you build it. Where it runs, how it grows, how it recovers, all of that stays the fabric’s concern. That is the real gift of the separation. You get to think about what you are making with the chips, not about the machinery that keeps everything in place and allows it to scale.
GPFS is a data fabric, not a directory
The same mistake can show up on the data side where some people might picture GPFS as a fast shared folder. GPFS is an entire data fabric and the global namespace it offers is only the front door.
Underneath, GPFS (IBM Spectrum Scale) is a policy engine for data. Information lifecycle management moves data across storage pools, flash, disk, and tape, by policy rather than by hand, so hot models sit on fast media and cold state ages out without anyone babysitting it. Active File Management caches and replicates data across sites, literally across the world in many cases, over NFS or the native GPFS protocol, so a model trained at the core is present at the edge when it is needed and writes reconcile back without a manual sync. Transparent cloud tiering pushes cold data out to object storage and pulls it back on demand, so capacity is effectively elastic. The same data is reachable through multiple protocols at once, POSIX, NFS, SMB, S3-style object, even HDFS, so different consumers touch one copy through whatever interface suits them. Content-aware policies scan metadata and extended attributes to place and act on data by what it is, not just where it sits, and clustered file events let a write itself trigger work, so the storage layer can drive the fabric data-first. Snapshots, encryption, and end-to-end integrity keep model and state provenance intact across all of it.
These are levers we don’t always pull and ones I don’t always focus on in demos, but they are there, and they push the design well past storage into distribution, adaptation, and resilience. A neuromorphic node backed by this is not an isolated box with a chip in it, instead it is a participant in a data fabric that spans edge, core, on-premise in the data center, and in the cloud.
One peer among many
None of this is about making everything neuromorphic. The point was never to crown a new center of the stack. Akida is one peer among many, each resource keeping the function it does best: CPUs for control and orchestration, GPUs for dense training and large-model work, storage for state and lifecycle, and Akida for low-power event-driven sensing and inference. The genius of the heterogeneous approach is not any single layer, it is all of it working together. The orchestration and data fabrics are what make that cooperation real. Put simply, this is what a heterogeneous compute ontology actually is and what makes it so powerful.
It is worth lingering on that word. In Return of the Jedi, Vader turns Luke’s new lightsaber over in his hand and says, “I see you have constructed a new lightsaber. Your skills are complete. Indeed, you are powerful, as the Emperor has foreseen.” The weapon is already built. The skill is already there. That is the position we are in and the power you might otherwise attempt to summon with a new neuromorphic operating system is already constructed and resident in the fabric we have: Symphony’s orchestration, multi-tenancy, preloaded models, fault tolerance, GPFS’s lifecycle management, caching, tiering, content-aware policy, and Akida seated among other device capabilities as a peer. There is no new weapon to forge. The skills are complete. The work is to wield what the ontology already gives us. And for anyone still inclined to underestimate what neuromorphic computing and a real compute ontology can do together, I will borrow one more line from that same scene: you don’t know the power of the Dark Side. 🙂
Where Akida can dominate
Heterogeneous by default does not mean heterogeneous always. The same ontology supports a very different mix and there are bounded domains where Akida should carry most of the load. The honest word is dominant rather than pure, because something always has to drive the devices, move I/O, and persist state. What changes is the ratio. In a domain that is genuinely event-driven, sparse, sensory, and adaptation-heavy, the chips handle the standing work, always on and at sub-watt, while the conventional compute recedes to a thin supervisory shell.
This is the same pattern we already accept with quantum and the comparison is worth making it plain. A quantum processor does not run a whole application. Today, quantum is handed a bounded problem, does the part it is uniquely good at, and returns the result to classical compute. However much quantum you do today, sooner or later it comes back to classical computing. Neuromorphic is the same kind of citizen. Both are non-von-Neumann acceleration, both can be dominant rather than pure, and both belong in the heterogeneous compute ontology as peers to CPU, GPU, and storage rather than a replacement for any or all of them. No one proposes a quantum operating system to own the data center for the same reason neuromorphic does not need one either. Nor does quantum or neuromorphic computing need to earn a seat at the table, they are already there ready to deal. The heterogeneous compute ontology put neuromorphic computing there, but really it belongs there by design, a true peer alongside quantum, GPU, CPU, and storage, each invoked where its physics wins.
Dominant neuromorphic compute solves problems where most of the time nothing happens and the constraints are power, density, and the ability to keep learning: continuous RF and electromagnetic monitoring, acoustic and vibration sensing, video motion and anomaly, network-traffic anomaly detection, anything always on and watching for that rare salient event. A rack of conventional compute is the wrong tool for standing watch. A dense fabric of neuromorphic chips, each sipping power and firing only on events, is exactly right.
How it works in practice is the architecture I have been building. Perception, novelty detection, classification, and on-chip adaptation run continuously on the fabric as faculties, learning what normal looks like in place rather than waiting for a retrain-and-redeploy cycle. Symphony decides which model sits on which chip and keeps faculties redundant across the fabric, so the same column lives on more than one chip and the cognition never rests on a single point. GPFS stages models and persists the learned state so adaptation survives restarts and migrations. The sleep-like consolidation people imagine becomes a concrete offline pass: during low activity, re-distill and prune the learned signatures, then reload the chips with the consolidated model. None of that needs a new operating system, it only needs roles on a fabric.
One of the pieces today that stays heterogeneous is knowledge recall. An LTI neuromorphic model does skill and classification extremely well, but it does not do in-context copy, so factual lookup rides on retrieval, which is host-and-storage work. That is not a weakness to engineer away, it is the ontology telling you which layer owns which job.
The deepest version of neuromorphic computing is not my idea, it is Peter van der Made’s. In his book Higher Intelligence he made the case for building machines on the brain’s own principles and he built Akida around one of them: the cortical column, a small, repeatable unit of computation that the neocortex stacks by the millions into perception, memory, and thought. That is the architecture he has been pointing at all along. The idea is not one monolithic processor but a fabric of columns, event-driven and sparse, that compose into something larger than any one of them. He realized the column in silicon. What I have been doing is carrying his legacy one level up, distributing those columns across a system through the heterogeneous compute ontology, so faculties spread across many chips and many nodes compose into one larger cognition. The same primitive, made real on the chip by van der Made and across the fabric by the ontology.
This is where neuromorphic becomes something more than sensory and more than the edge. No one talks about their own senses as the edge of their personhood. What you see, taste, touch, and smell is not a peripheral. It is you encountering the world. The potential of van der Made’s design is for neuromorphic computing to do the same, to experience that world and learn from it. The heterogeneous compute ontology then expands that vision from one mind to many. My recent demos imagine exactly that: a council of minds, where many faculties deliberate, each a column with its own view, converging on a decision no single one holds, a constellation network for space, where neuromorphic nodes ride on satellites, sip power, run for years, tolerate intermittent links, and keep sensing and deciding on their own, because event-driven, sub-watt, autonomous cognition is precisely what orbit demands and precisely what conventional accelerators cannot sustain there. These are not metaphors stretched over a CPU. They are domains where neuromorphic is the right and dominant answer and where van der Made’s column, replicated across a fabric, is the natural shape of the solution.
Writing this, I’m reminded of an old Doobie Brothers song and the chorus, “Old black water, keep on rollin’, Mississippi moon, won’t you keep on shining on me.” It is a song about nothing more than meeting the world and letting it roll on, and the longer I sit with it the more the river looks like the chip. A neuromorphic fabric is black water. It runs dark and quiet, sub-watt, staying dark until the world wakes it, the way the Mississippi lies black under the night and only catches the light when the moon comes out. Its neurons do not fire on a clock. They fire on events, on the world stirring against them, and the rest of the time they rest. You only see the rapids when the water hits the rocks, and that is the point: the fabric shows its work only where the world pushes against it, bright and sparse against the dark, spending nothing on the smooth water in between. It deeply flows where it goes, finding its own path rather than waiting to be told one, gathering a thousand tributaries into a single dark current the way a cortical complex gathers a thousand columns into a single mind. A neuromorphic fabric does not command the world. It encounters it, learns from it, and keeps on rolling, on its own, the way a river does not need permission to run.
So the Akida-dominant case and the heterogeneous mix are not two architectures. They are the same compute ontology with the mix dialed toward neuromorphic exactly where the domain rewards it: event-driven, sparse, sensory, adaptation-heavy. Dial it the other way for control and large-model reasoning and neuromorphic and GPU work together along with all the others. The power of the ontology is that the ratio moves with the problem instead of forcing one shape on everything.
Why this matters
The name shapes the design. Call a coordinating substrate an operating system and you start reasoning as if you must own the kernel, replace what is beneath it, and control the whole stack, building lock-in and reinvention instead of composing with the layers that already work. We have seen plenty of vendors brand a coordination layer an “operating system” to claim total control of the stack with their own ontology. Look closely and that “OS” is standing on the same foundations most everyone else uses: Linux underneath, a specialized fork of Kubernetes for orchestration because standard K8s can’t do it alone, commodity hardware on-prem or in the cloud, and ordinary storage. There is nothing wrong with building on those, though Kubernetes is not always the right fit, and making it appear as though it is the universal substrate for every problem is exactly the sort of mistake that becomes easy to make once you think you own the OS layer. Symphony exists precisely because low-latency service-oriented grids are not what Kubernetes was built for in the first place. What is wrong is hiding any of it behind a label that implies you invented the whole stack. Why? Because here the label is doing the work of a moat, not truly defining your system. And the cost is real. By pretending the layers are one proprietary block, you forfeit the very thing honest layering gives you: the freedom to swap, extend, and let each layer advance on its own. You shortchange what is otherwise possible in exchange for the appearance of owning it. In one sense, it is good marketing that plays fast and loose with the words, but in another sense it is the very ambiguity involved that makes up the equivocation. The gap between what you’re really doing and what you present as your company’s moat is where good design goes to die.
Keeping the lines drawn where they belong is not some kind of petty detail. Good design is built on appropriate definitions that lets each layer do its job and improve at its own pace: Linux drives the silicon, Symphony orchestrates the fabric, GPFS moves and protects the data, and your services carry the intelligence. Blur those lines under one grand “OS” and you inherit all of their responsibilities and none of their maturity.
So this is the shape I am building toward: Linux where Linux belongs, Symphony and GPFS as the fabric, what you build with the chips kept as yours to design, and a heterogeneous compute ontology that recognizes Akida as a first-class, orchestrated, self-healing citizen of the enterprise on par with quantum, GPU, CPU, and other resources available in the enterprise. The heterogeneous compute ontology here is the wider and greater vision deployable today.