Edge AI for autonomous robotic systems and defenseChandler, Arizona
Cloud-class AI, pocket-sized.
Morphos builds edge AI frameworks that bring high-capability AI into form factors small enough to go where the cloud can’t. On the machine. Off the grid. Ready when the mission changes.
The problem
The machines are coming. Their brains are still in the data center.
AI is moving out of the data center and into machines that have to think for themselves. The problem is that the most capable AI still depends on data-center-scale memory, power, and cooling. Field systems get smaller models trained in advance, and teaching them something new usually means collecting data, retraining, and redeploying software across the fleet. That can take weeks. The mission changes in hours.
The hard part isn't getting AI onto the machine. It's changing what the machine knows once it's out there.
Whatever the battery gives you.
Every gram costs range or payload.
No cooling beyond the air around it.
Often slow. Sometimes gone.
Retraining takes weeks. A mission takes hours.
Everything the machine knows has to fit on board.
The solution
We split the brain.
DarkStar separates the part of AI that recognizes from the part that knows. A compact onboard model identifies what the sensors see, while a small, swappable memory holds the mission-specific knowledge: what it is, what it means, and what to do next. Instead of retraining the model every time the mission changes, you update the memory.
Update the knowledge. Keep the model.
When the model has to change
Collect new examples, retrain the model, test the new version, then push it across the fleet. That can take days or weeks—and usually requires significant compute and engineering work.
WITH DARKSTAR, WHEN ONLY THE KNOWLEDGE HAS TO CHANGE
Prepare the new mission memory, verify it, and load it onto the machine. The underlying model stays in place.
The model recognizes. The memory knows.
Mission knowledge lives in compact memory instead of being baked into a larger model, reducing what the machine has to carry and run.
Recognition, retrieval, and decision support happen locally. The machine doesn’t need a cloud connection to access what it knows.
New objects, environments, or mission knowledge can be added by updating the memory instead of retraining the underlying model.
DarkStar’s memory can remain small enough for constrained hardware because Green Vectors dramatically reduce the amount of vector data required to represent useful knowledge.
Building your own hardware? DarkStar can also integrate directly into platforms you already build through our SDK. EdgeRunner is the fastest way to deploy the complete system, but it isn’t the only way.
The hardware
Meet EdgeRunner.
EdgeRunner puts DarkStar into a compact, self-contained compute unit you can mount directly on a machine. It connects to the platform’s existing sensors and systems and runs recognition, memory, and decision support locally—without depending on a cloud connection. Put it on a drone, robot, vessel, vehicle, or fixed sensor. The intelligence stack stays the same. The platform is up to you.
Swap a Cartridge.
Change the Mission.
When the machine needs to recognize or handle something new, load a different EdgeRunner Cartridge containing the knowledge for that mission. No model retraining. No new software build pushed across the fleet.
EdgeRunner Shell
The physical compute unit. Processor, memory, storage, interfaces, and the DarkStar runtime in one compact enclosure designed to connect with the platform’s existing sensors and systems.
EdgeRunner Cartridges
The machine’s mission memory. Each Cartridge contains the objects, environments, signatures, and other knowledge required for a specific task. Change the Cartridge, and you change what the machine knows.
EdgeRunner OS
The control layer connecting sensors, DarkStar, and the platform. It receives sensor data, runs recognition against the active Cartridge, and passes the resulting information to the machine’s autonomy stack or operator.
Where it goes
Built for the places the cloud can't be counted on.
Any platform that has to see, understand, and decide on its own—with limited power, limited space, and connectivity it can’t rely on.
Hover or tap a platform to see what changes for it
Target applications. Integration depends on the platform, the sensor, and the task.
What that makes possible
Put it all together and the machine stops being a sensor waiting for instructions. It becomes something you can give a job to.
Not a flying camera phoning home. A quadcopter that recognizes, decides, and remembers on its own, on a battery, in a place with no signal.
Every manual, procedure, map, and lesson learned for a site, on the machine and searchable in the moment. We’ve already demonstrated the underlying idea by putting AI searchable Wikipedia on a Raspberry Pi.
Load new mission memory and every machine can recognize something new without retraining the underlying model or rebuilding the entire software stack.
What one machine encounters in the field can be reviewed, incorporated into future mission memory, and distributed across the fleet.
When the thinking happens on board, nothing has to be streamed anywhere. A platform can operate under emission control, transmitting only conclusions, rarely, or nothing at all. Less to intercept. Less to jam. A smaller signature.
The breakthrough behind DarkStar
The secret is the memory.
A vector is how AI turns information into numbers so it can compare meaning and similarity. Modern AI systems can store millions or billions of these representations as searchable memory.
Giving an AI system searchable memory isn't new. Making that memory small enough to travel with the machine—without throwing away the meaning that makes it useful—is.
That is what Green Vectors does. Instead of treating every new piece of information as another independent vector to store and search, Green Vectors continuously organizes knowledge into compact semantic representations.
- It organizes. Related information is grouped around shared meaning, so redundant knowledge doesn't have to become another standalone vector every time it appears.
- It weighs. Not every piece of information should influence memory equally. Green Vectors can weight new information by relevance, frequency, recency, or other signals as it becomes part of the memory.
- It keeps everything connected. Large sources are organized hierarchically, keeping specific details connected to the larger documents, sections, and ideas they came from.
The result isn't conventional compression. It's a different way of organizing vector memory. In our Project Gutenberg benchmark, an index built from roughly 15 million traditional vectors fell from 260 GB to 1.3 GB—a 99.5% reduction—while retrieval results moved closer to the correct answer rather than farther away.
Green Vectors makes the memory small enough to carry. DarkStar turns that memory into intelligence a machine can use. EdgeRunner packages the system into hardware you can mount, power, and deploy.
Why we expect it to travel: Green Vectors operates on vector representations, not on one particular kind of source data. Text, imagery, sensor data, and other inputs can all become vectors. That makes the architecture portable across workloads; performance on each platform still has to be measured and validated.
How far can the same memory travel?
Memory, not disk. To answer fast, a memory has to be resident on the platform, and that's the scarcest thing on board. Here's what fits where, using the measured sizes, from a data center down to a handheld.
At 50,000 books, the conventional memory needs 264 GB and fits only a data center. After 1-bit quantization it needs 12.1 GB and fits down to an autonomous platform, with accuracy given up to get there. Green Vectors needs 5.3 GB and fits all five, down to a handheld.
Footprints are the measured sizes from the 50,000-book study (260 GB conventional, 8.1 GB after 1-bit quantization, 1.3 GB Green Vectors) plus a 4 GB allowance for the model and runtime. Larger collections scale the measured sizes proportionally, which is an assumption. Memory budgets are selected examples, not device specifications. Source-document storage is not included. This shows what fits in memory, not demonstrated deployment, power, or thermal performance. The quantization tradeoff shown here describes this comparison, not every quantization method. More on the Green Vectors page
Measured on public and enterprise data. The first patent application has been allowed. In use with evaluation partners through our SDK.
The architecture is patent-pending. Benchmarks on embedded hardware are underway, with first results expected this year.
In prototype, with evaluation programs open to defense and autonomy partners.
Work with Morphos
Tell us where your machines need to think.
Air, ground, surface, subsea, or a sensor on a hillside. Bring the platform, the task, and the limits it has to live within. We'll bring the intelligence.