A patented architecture that composes learned models with verifiable rules — every decision traceable, every constraint proved, from a $4 microcontroller to a 1,000-stop fleet.
GenesisNode pairs gradient-free graph learning with a composable rule engine. Machine learning proposes, the rules verify, and every output ships with an auditable explanation. No matrix multiplication. No black boxes. No catastrophic forgetting.
// the problem
A confidence score is not an explanation. When a model can’t show why it decided, regulated and safety-critical operations can’t audit it, can’t certify it, and can’t defend it after the fact.
Learned optimizers produce plans that look right and break hard rules — overweight loads, missed delivery windows, unsafe engagements. In our baseline test, an unverified neural classifier produced 78 constraint violations.
When traditional networks learn new behaviors, they overwrite what they already know. Retraining from scratch is expensive, slow, and operationally disruptive.
// the architecture
GenesisNode represents knowledge as a sparse weighted graph of nodes connected by context-tagged edges, trained by genetic evolution rather than backpropagation. On top of the learned graph sits a composable rule engine: hard constraints and doctrine composed into directed acyclic graphs that verify every proposal before it becomes a decision.
Inference is a breadth-first search through the node graph — pure dictionary lookups, no matrix multiplication. This is why inference runs in 27 microseconds on desktop CPU with no GPU required, and why every prediction comes with the exact firing chain that produced it.
Hard constraints — stacking safety, delivery windows, rules of engagement — are composed into DAGs with isolated namespaces. Learned proposals that violate a rule are rejected before they act, and every accepted decision carries a proof certificate documenting constraint satisfaction.
Each new capability level gets its own proxy nodes, structurally separate from prior knowledge, with routing confined to its own namespace. Training a new task cannot modify what the network already knows. Protection is architectural, not probabilistic.
A quality gate monitors foundational capability retention during every new training phase. If retention drops below threshold, the checkpoint is rejected. L1 retention maintained at 98.7% across 10 sequential training phases.
Performance figures measured on training-set recall benchmarks and desktop CPU. Held-out generalization benchmark: 6.4% exact match, 12.9% top-5 on unseen common sense triples. Physical ESP32 deployment in progress.
// see it run
GenesisNode composes learned models with verifiable rules, so every decision is traceable. Fourteen live demos span three portfolios — from training a network in your browser to constraint-proved logistics planning to assured engagement decision support.
6 demos
The core architecture, live: train language capabilities L1–L10 in your browser and watch the node graph form, benchmark MNIST digit classification on the GPU engine, and explore robotics, IoT, and Arduino simulations — with an assurance dashboard exposing the audit trail behind every decision.
Explore AI Research →4 demos
Constraint-verified planning for distribution operations: build multi-temperature trailer loads with a proof certificate on every load, replenish perishables inside hard guardrails, re-plan disruptions in seconds, and dispatch fleets validated against CVRP benchmarks up to 1,000 customers.
Explore Supply Chain →4 demos
Assured engagement decision support: doctrine-derived rules composed into verifiable DAGs, from a static baseline through a closed-loop OODA kill web to a full 94-rule doctrine architecture. A CNN alone produced 78 constraint violations — routed through a 25-rule doctrine DAG, zero.
Explore Defense →Explore all three portfolios live. Open the interactive demo →
// the numbers
| Metric | GenesisNode | Transformer | TFLite Micro | Traditional RL |
|---|---|---|---|---|
| Inference | 15–70 µs | 1,200–9,000 µs | 500–2,000 µs | 100–500 µs |
| Model size | 1–50 KB | 50–500 MB | 50–500 KB | 1–10 MB |
| Training | Online, no GPU | GPU required | GPU + quantization | GPU required |
| Explainability | Full firing chain | Opaque | Opaque | Reward signal only |
| Output verification | Rule-engine proof certificates | None | None | None |
| Catastrophic forgetting | None (10 levels) | Common | Common | Common |
| Min hardware | Arduino Nano ($3) | GPU server | Cortex-M4 ($5) | GPU server |
// how we’re applying it
Every GenesisNode application follows the same pattern: a learned model proposes a decision, a composable rule engine verifies it against hard constraints, and the result ships with a complete, auditable explanation. We’re applying that pattern across three portfolios today — each one running live in the interactive demo.
Distribution operations where a plan that merely looks good isn’t good enough. GenesisNode builds multi-temperature trailer loads under six hard constraints — stacking safety, delivery windows, driver hours among them — and attaches a proof certificate to every load documenting constraint satisfaction. Forecast-driven perishable replenishment runs inside mandatory guardrails for shelf-life coverage, case-pack rounding, and vendor minimums. When a reefer fails or a road closes, affected loads are re-planned in seconds with compliance proved — untouched loads stay untouched. Fleet dispatch adds live rule editing and backtesting on top.
Explore the supply chain demos →Engagement decisions demand formal guarantees, not confidence scores. GenesisNode composes doctrine-derived rules — rules of engagement, battle damage assessment, commander’s decision elements — into directed acyclic graphs that verify every recommendation before it’s authorized. In our baseline validation, a convolutional neural network alone produced 78 constraint violations; the same classifier routed through a 25-rule doctrine DAG produced zero. The full architecture scales to 94 rules across 13 isolated namespaces, evaluated in a closed OODA loop.
Explore the defense demos →The architecture’s original home: anomaly detection and control at the sensor, on microcontroller-class hardware, with no GPU and no cloud dependency. GenesisNode trains on your equipment’s specific signal patterns and keeps running through network outages. The IoT and Arduino simulations demonstrate the full lifecycle — telemetry tokenization, anomaly detection, pin-level hardware control — on kilobyte-scale models suited to hardware costing less than a sensor cable.
See the IoT & Arduino sims →The foundation under all three portfolios: sparse selection-based computation with self-organizing nodes, trained without gradients. Language capability is built in ten sequential levels without erasing what came before — train it live in the browser and watch the node graph form and specialize. A MNIST vision benchmark runs the same architecture on a GPU engine at roughly 129x the CPU routing speed. The assurance dashboard exposes audit trails, write protection, and building-block analysis for every trained model. This track anchors our non-provisional patent and arXiv work.
Train it in your browser →// the moment
Every serious AI deployment conversation now ends at the same question: can you prove it? Learned models keep getting better at proposing answers — and no better at guaranteeing them. GenesisNode treats verification as architecture, not afterthought: a rule engine composed from your constraints sits between every learned proposal and every action.
This is not a compressed transformer with a policy filter bolted on. It is a different computational primitive — a sparse graph that grows only the nodes it needs, never touches prior knowledge when learning something new, and pairs every decision with a proof.
We are in early commercial development, actively seeking pilot partners in distribution, manufacturing, and defense, plus research collaborators for the non-provisional patent and arXiv submission.
// get involved
If you run distribution operations, manufacturing equipment, or mission-critical decision systems and want to see GenesisNode verifying decisions against your own constraints, we want to talk. Pilots are structured as a fixed-scope engagement: encode your hard constraints as rules, train a model on your operational data, and deploy — on existing hardware, at the edge or in your stack.
For research and partnership inquiries: research@genesisnode.ai
For press and investment: brian@genesisnode.ai