The flight simulator for any AI-powered machine.
Etalonis is where autonomous AI is trained, rehearsed and validated against a fixed reference standard — the étalon — before it ever runs on a real machine. A platform-agnostic digital-twin sandbox that runs thousands of scenarios a day, produces the proof, and delivers validated software with a proven hardware configuration to run it on, unchanged in the field. Built by Aimrika.
Robots can be built faster than they can be proven safe.
Real-world trials can't deliver the scale, safety or speed autonomy needs. The rare, critical conditions that matter most — the sensor failure, the degraded weather, the near-miss between two machines — are exactly the ones hardest and riskiest to test for real. You cannot crash your way to a dependable autonomous system.
01 Scale the real world can't provide
Physical AI needs millions of experiences across conditions no live programme can afford to reproduce — gravity, inertia, causality, failure.
02 Safety limits live testing
The behaviours that make a machine truly autonomous are the ones hardest, and most dangerous, to rehearse for real.
03 The edge cases are the point
The situations that matter most are exactly the ones you can least afford to stage in reality — so they go untested until they happen.
04 Proof, not just a demo
A system that looks good in one run isn't validated. Trust needs a fixed standard, applied every time, that a result can be measured and audited against.
Three things, in sequence — not just a simulator.
Etalonis doesn't stop at running a scenario. It produces the environment, the proof, and the validated software you actually run in the field — in that order, every time.
The simulation & validation sandbox
A platform-agnostic digital-twin sandbox running thousands of realistic scenarios a day, available today. Every candidate change — a new sensor, a retrained model, a software update — runs here first, across weather, terrain, lighting, sensor noise and induced failures, at a scale no physical test programme can match.
A validation authority, not a demo
Every candidate is scored against a fixed reference standard — the étalon — on identical scenarios and identical physics. Because everything except who is acting is held constant, every difference in outcome is attributable to the agent alone. The result is comparable, reproducible and auditable. See the full method below.
Validated software + a proven hardware configuration
Etalonis doesn't just grade a run — it produces validated, deployment-ready software and tells you exactly which edge-AI hardware configuration to run it on, benchmarked and ready to deploy unchanged on the real machine. Flying vehicles today; ground and maritime robots next — carrying software that's already been proven, not guessed at.
Train → Rehearse → Coordinate → Validate → Deploy.
The same AI agent that passes Etalonis runs unchanged on the real edge hardware aboard the real machine. Real-world operation confirms the result; it does not discover it.
Train
The agent learns to perceive, navigate, act, recover and adapt across weather, terrain, lighting, sensor noise and induced failures.
Rehearse
The exact task — environment, route, objects, conditions — is run to standard in the sandbox. A true dry run, no risk, no cost.
Coordinate
Fleets of robots, drones and vehicles learn to operate as a team — the multi-agent rehearsal the real world can rarely afford.
Validate
Every behaviour is benchmarked against a reference system on identical scenarios and physics — the etalon.
Deploy
The validated agent runs on the real machine. Real-world operation confirms; it does not discover.
Prove, don't assert.
No capability is "done" until it beats a control, repeatably. Etalonis is named for this standard — the étalon, the reference against which everything is measured.
- What a reference system actually is. A mature reference implementation that performs the task under the same physics, the same scenario and the same conditions — the achievable ceiling the candidate agent is measured against.
- What "identical" means in practice. Identical digital-twin geometry, sensor models and physics parameters between the control run and the candidate run. Everything is held constant except who is acting, so any difference in outcome is attributable purely to the agent.
- What a validation result looks like. A scored comparison — task success, track/behaviour error relative to the control, degraded-condition recovery, and reproducibility across repeated runs — not a single cherry-picked run.
- Why this is an authority, not a demo. The same fixed standard is applied every time, to every candidate. That is what makes a result comparable, reproducible and auditable — the opposite of a one-off simulation staged to look good.
Evidence that integrators and regulators can use.
Robots, vehicles, vessels and aircraft that work near people need evidence that their AI is accurate and robust on the hardware it actually runs on. The rules for that evidence are being written now. Every Etalonis validation run is designed to produce it, following the relevant parts of these standards. We follow them; we do not claim certification against them.
| Standard | How we use it |
|---|---|
| Machinery Regulation (EU) 2023/1230 (applies from 20 January 2027) and EN ISO 10218-2:2025 | The requirements for AI-enabled machinery and collaborative robot applications. Integrators must show their AI performs; we produce that evidence. |
| ISO/IEC TR 5469 | AI is not declared a safety function. Protection of persons stays with certified safety devices; our detectors supply the recall and latency evidence. Evidence, not certification. |
| AI Act Art. 15 | Accuracy and robustness expectations for AI systems, measured per model and per hardware tier. |
| prEN 18281 (draft) | Computer-vision accuracy evaluation. We follow its object-detection parts now. |
| prEN 18229-4 / -5 (draft) | Accuracy and robustness of AI systems. |
| ISO/IEC TR 24029-1 | Robustness assessment of neural networks. |
| ISO/IEC 5338 and ISO/IEC 5259 | AI-system lifecycle and data quality, followed in their relevant parts for verification and data quality. |
| MLPerf Inference (edge) methodology | Our scoring discipline: a fixed reference model, a fixed test set and an accuracy-retention floor. Not an MLPerf submission. |
The same logic applies in aviation. Under EU drone regulation (2019/947), a drone over 25 kg, or one flying beyond visual line of sight, above 120 m or over people, needs a full risk assessment (SORA) and, at the top end, an EASA design verification. Proving a single software change by flying a real aircraft many times over is slow, and often not permitted before the first flight is cleared. Etalonis is designed to run those iterations in a digital twin first and to record the evidence as it goes.
The engineering foundation already exists.
Etalonis is not a concept — it is running infrastructure: a validation ladder from simulation to software-in-the-loop to hardware-in-the-loop on production edge hardware, with every run scored against a reference result. Proven first on an aerial platform, the same method applies to ground, maritime and industrial robots.
| Capability | What it means in practice |
|---|---|
| Host-to-device gap, measured | The same scoring runs on the training host and on the edge device, so the accuracy lost between them is a measured number, not a hope. |
| Cross-stack benchmarking | Each model is compared across sizes, architecture generations, devices and software stacks (TensorRT/DeepStream, ONNX Runtime). An external ROS 2 / Docker autonomy stack has been benchmarked on our own Jetson hardware. |
| Platform-agnostic | Built on an aerial platform first; the same methodology and edge-compute architecture apply to ground, maritime and industrial robots. |
| Hardware right-sizing | We don't just validate the AI — we tell you what to run it on. Each workload is matched to the cheapest, lowest-power hardware tier that still clears its performance bar — from a Raspberry Pi 5, through the full NVIDIA Jetson family, up to NVIDIA DGX Spark-class compute — instead of over-provisioning every machine. |
On the roadmap, not yet demonstrated: visual place recognition (localisation from what the machine sees, without satellite positioning) and multi-agent rehearsal at fleet scale.
The full edge-to-server spectrum, owned — and measured tier by tier.
We run the same models across the real hardware spectrum, measure them, and tell you which tier actually earns its cost for your workload. Every tier listed is owned outright. Two are operational today — Jetson Orin Nano Super and Jetson Orin NX, benchmarking production models; the rest are procured and not yet connected for benchmarking.
| Tier | Device | Performance | Status |
|---|---|---|---|
| Entry | Raspberry Pi 5 + Hailo-8L accelerator (~€70 accelerator) | 13 TOPS | Procured, not yet connected |
| Entry+ | Raspberry Pi 5 + Hailo-8 accelerator | 26 TOPS | Procured, not yet connected |
| Mid | NVIDIA Jetson Orin Nano Super | 67 TOPS | Operational |
| High | NVIDIA Jetson Orin NX | 100 TOPS | Operational |
| Efficiency | SiMa.ai Modalix | 50 TOPS at 8–12 W | Procured, not yet connected |
| High+ | NVIDIA Jetson AGX Orin 64GB | 275 TOPS | Procured, not yet connected |
| Server-class | NVIDIA DGX Spark (Grace Blackwell) | ~1 PFLOPS | Procured, not yet connected |
Maritime detection, live 24/7
mAP50 0.947 — 63.7 FPS DeepStream inference, 39.9 FPS end-to-end, serving a live, round-the-clock camera pipeline. Not a demo number — the measured output of the same pipeline we benchmark every tier with.
Civilian-only detection
Explicitly tested to reject the non-target class: a 500-image rejection test at a 1.4% false-positive rate (pass).
The three computers of physical AI.
Physical AI stands on three computers: one to train the model, one to simulate the world, and one to run inference at the edge. Etalonis is the second — and we make it a validation authority.
Train
The AI is trained on commodity GPUs — the AI factory that turns data and experience into capability.
Simulate
The world model and sandbox where the agent lives thousands of lifetimes across digital twins — built and validated at a scale and speed the real world can't match. We add what general world models lack: a validation authority.
This is EtalonisInfer at the edge
The validated agent runs on an edge module aboard the real machine — perception to decision to action in real time, on-device, with no cloud and no operator. Target hardware spans a Raspberry Pi 5, the full NVIDIA Jetson family, up to NVIDIA DGX Spark-class compute.
One engine. Wherever autonomy must be trusted to act.
The same environment, methodology and edge-compute architecture apply across domains — each with its own validation problem that reality is slow, costly or unsafe to reproduce.
| Domain | The validation problem simulation solves |
|---|---|
| Inspection | Rehearse rare fault conditions and hard-to-reach geometry before sending a machine to find them for real. |
| Logistics | Prove reliable behaviour across the long tail of routes, loads and obstacles that a live fleet meets only occasionally. |
| Mobility | Stage the near-miss and the sensor failure safely, thousands of times, instead of waiting for them on the road. |
| Agriculture | Seasonal, weather-dependent conditions are expensive and slow to wait for in reality — simulate the season, not just the machine. |
| Mapping | Validate navigation and localisation across environments and lighting no single survey campaign could cover. |
| Maritime | Sea state, degraded visibility and GPS-denied navigation rehearsed before a vessel ever leaves port. |
| Energy | Inspect and operate around high-value, high-risk infrastructure where a real failed trial is not an option. |
| Search & rescue | Practise the exact conditions that matter most — the ones too rare and too dangerous to stage on demand. |
Illustrative of the validation problems Etalonis addresses across domains; not a claim of delivered projects in each vertical.
Proven first on flight. Built to generalise.
Proven first on a flying-vehicle platform. The same environment, methodology and edge-compute architecture are built to generalise to ground vehicles and maritime vessels as the product roadmap extends.
The company behind Etalonis.
Etalonis is built by Aimrika GmbH, founded by Volodymyr Levykin — previously founder and CEO of Skyrora, the British orbital-launch company, through to its 2024 sale — ESA- and UK Space Agency-backed, with delivery inside the EU-wide MADE-3D research programme (Horizon Europe GA 101091911). The conviction is the same: real capability, built honestly, proven before it ships.
Put Etalonis in front of your hardest validation problem.
For a technical briefing, a pilot, a partnership or an integration enquiry — reach out and tell us what you're trying to prove.