We build the AI that trains physical AI.
Aimrika builds Etalonis — the simulation environment, a sandbox for the digital twins of tomorrow's robots, where autonomous AI is developed, tested, and validated at scale before it ever operates in the real world. Etalonis is the flagship. Trusted autonomy is the product.
You cannot build trustworthy physical AI in the real world alone.
Robots, drones and autonomous vehicles need millions of experiences to become reliable — but the real world can't deliver them safely, cheaply, or fast enough. The systems that most need to be tried thousands of times are the ones that are hardest, and riskiest, to run even once.
01 Real trials are slow and costly
Every real-world run of a robot or vehicle burns time, hardware, and engineering effort — you can iterate only a handful of times a day.
02 Safety limits live testing
You cannot crash your way to a dependable autonomous system. The behaviours that make a machine truly autonomous are the ones hardest to rehearse safely for real.
03 The real world can't provide scale
Physical AI must learn the common sense of the world — gravity, inertia, object permanence, causality — across conditions no live programme can afford to reproduce.
04 The edge cases are the point
Rare weather, sensor failures, unexpected obstacles — the situations that matter most are exactly the ones you can least afford to stage in reality.
Etalonis — the sandbox where physical AI is built and proven.
We move the experience into simulation and keep only the irreducible minimum in the real world. A high-fidelity development, testing and validation environment that runs thousands of scenarios a day — and the same AI agent that passes Etalonis runs unchanged on the real edge hardware aboard the real machine.
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.
And the loop closes. Every agent that passes Etalonis leaves behind validated behaviour — scenarios, edge cases and reference runs — that becomes training data and the benchmark for the next machine we validate. Each validation makes the next one faster and better grounded: AI that helps train the next physical AI, through repeatable validation and reuse.
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 environment
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, at a scale no physical test programme can match.
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.
The machine itself
Flying vehicles today; ground and maritime robots next — carrying software that's already been proven, not guessed at.
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 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. We build the one that matters most when you cannot iterate in reality — the simulation computer — and make it a validation authority.
Train
The AI is trained on commodity GPUs — the AI factory that turns data and experience into capability.
Simulate — Etalonis
The world model and sandbox where the agent lives thousands of lifetimes across digital twins. It is where the agent can be built and validated at a scale and speed the real world can't match — and we add what general world models lack: a validation authority.
This is what we buildInfer 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. One pipeline (PyTorch → ONNX → TensorRT FP16) takes a model from training to deployment, benchmarked across a range of edge-AI hardware.
When autonomy is software, it follows the software lifecycle.
Program the behaviour, rehearse it in the simulation sandbox, validate it against the etalon, and only then deploy — exactly the lifecycle software already has. Etalonis is the development environment for physical AI.
| Software lifecycle | What we enable — autonomy as code |
|---|---|
| Write the code | Program the behaviour — the task and course of action |
| Test in CI / sandbox | Rehearse in the simulation sandbox — the dry run |
| Review gate | Validate against the etalon — the gold standard |
| Deploy to production | Deploy to the real machine |
| Runtime & observability | Live edge inference, telemetry and scoring |
One engine. A flagship, its digital twins, and the applications.
Etalonis
The simulation environment — the digital-twin sandbox for physical AI. Train, rehearse, coordinate and validate autonomy at scale, then deploy it unchanged to the edge.
High-fidelity twins
Photoreal, physics-accurate twins of robots, drones, ground vehicles and vessels — so the AI aboard many machines can be trained, synchronised and validated together, long before real deployment.
Autonomy across industries
One engine serves inspection, logistics, mobility, agriculture, mapping, maritime, energy and search-and-rescue — wherever autonomous machines must be trusted to act on their own.
Prove, don't assert.
No capability is "done" until it beats a control, repeatably. A mature reference system performs the task on identical scenarios under identical physics; its result is the achievable ceiling. The agent then performs the same task — and because everything except who is acting is held constant, every difference is attributable purely to the agent. Etalonis is named for this standard — the étalon, the reference against which everything is measured.
- Simulation is the authority, not the demo. Etalonis is where autonomy is built and validated; the real world confirms it.
- Single source of truth. Every behaviour, benchmark and decision is traceable — trust is earned by auditability.
- Honest by design. The same scoring runs in simulation, on the host and on the edge device, so the gaps between them are measured, not hidden. We never ship what we have not measured.
Volodymyr Levykin
Volodymyr was founder and CEO of Skyrora, the British orbital-launch company, through to its 2024 sale — a deep-tech venture that designed, built and test-fired rocket engines and launch vehicles in the UK and Europe, backed by ESA and the UK Space Agency, with delivery inside the EU-wide MADE-3D research programme (Horizon Europe GA 101091911). He has spent his career turning hard engineering into fielded capability.
Aimrika continues that mission on a new frontier: giving autonomous machines the proving ground they need to be trusted. The conviction is the same — real capability, built honestly, proven before it ships.
A growing team of IT and AI specialists.
Aimrika is building a five-person technical team, including the founder. These are the roles we are building out.
| Role | Focus |
|---|---|
| Founder & CEO | Technical direction and project leadership |
| AI Developer — edge-AI integration | Adopting, configuring and debugging new edge-AI hardware and toolchains |
| AI Developer — ML optimisation | Quantisation, pruning and tensor optimisation to meet performance and accuracy floors |
| AI Developer — recommendation engine | The engine that matches each AI workload to the right hardware tier |
| DevOps Engineer | Runtime routing and partitioned execution across the hardware fleet |
Building the proving ground for physical AI.
For partnership, pilot and collaboration enquiries, or to arrange a briefing on Etalonis.