Vary visibility, actors, timing and operating constraints inside a bounded scenario.
Vehicle assurance · prototype 0.1.0
Find the dangerous scenario before the road does.
Calyra explores the failures around a vehicle. Calybris evaluates the available actions, selects an allowed safe response and preserves the decision as replayable evidence.
- Pre-MVP prototype
- Built on Calybris Core 1.0.0
- Public evidence available
CALYRA / SCENARIO CONTROL 01 READY TO TEST
PHASEObserve
PERCEPTION96%
TIME MARGIN4.8 s
POLICYNominal
COMPOUND PRESSUREVan occlusion + pedestrian + wet roadVisibility, friction and closing speed vary together.
CALYBRIS 1.0.0 / RESPONSEReady for controlled runRun the case to produce a decision receipt.
TL;DR / Direct answer
What is Calyra?
Calyra is a pre-MVP mobility assurance prototype. It turns bounded vehicle hazards into reproducible scenarios. Calybris Core 1.0.0 evaluates permitted responses and records the result as replayable evidence; the browser lab above is an explanatory fixture, not a live simulator.
Keep the smallest reproducible world that still exposes the unsafe condition.
Link the selected policy-bound response to a stable replay and evidence identity.
01 / Responsibility boundary
One safety case. Three clear owners.
Calyra is not another vehicle simulator. It connects the world under test to a deterministic decision and a replayable proof trail.
Simulation environment
Physics, sensors, traffic actors and vehicle dynamics stay in the environments already used by mobility teams.
- CARLA
- Isaac Sim
- Gazebo
- ROS 2
Calyra
Constructs bounded worlds, introduces controlled pressure, searches for dangerous edges and reduces failures to reproducible counterexamples.
- Scenario identity
- Fault pressure
- Failure reduction
- Replay
Calybris
Evaluates candidate actions, applies hard policy constraints and preserves the selected allowed action as verifiable evidence.
- Continue
- Slow
- Stop
- Minimum risk
02 / Scenario field
Pressure the route. Preserve the reasoning.
Select a public-safe example to see how one mobility concern becomes a reproducible assurance artefact.
An occluded crossing becomes visible too late.
A road vehicle approaches a partially occluded pedestrian crossing while perception confidence changes inside a bounded interval.
01 / ScenarioBounded route identity
02 / PressureVisibility + perception confidence
03 / RiskStopping envelope narrows
04 / Safe actionControlled deceleration
05 / EvidenceDecision receipt + replay identity
03 / Mobility domains
Different vehicles. The same assurance spine.
Calyra carries one scenario and proof identity across road and controlled-site mobility without pretending the operating domains are identical.
Road vehicles
Occlusion, perception degradation and unexpected traffic behaviour around passenger and autonomous vehicles.
Open scenario↗AGV / AMR fleets
Human interaction, blocked aisles, changing payloads and energy margins in factories and warehouses.
Open scenario↗Yard & port vehicles
Constrained turns, sensor confidence and mixed traffic around loading areas and logistics yards.
Open scenario↗Site shuttles
Communication delay, route changes and minimum-risk behaviour across campuses and airports.
Open scenario↗
04 / Recorded evidence
Evidence without theatre.
The public browser experience replays recorded, sanitised fixture outcomes. It does not run Calyra, Calybris, CARLA or ROS 2 remotely—and it does not turn missing evidence into a green badge. The historical public pack below was recorded against Calybris 0.5.7 and remains labelled accordingly.
05 / Assurance outputs
A failure becomes something a team can act on.
The useful output is not a dramatic animation. It is a bounded, reproducible and reviewable safety artefact.
Coverage report
Which scenario dimensions and operating boundaries were exercised.
Minimum counterexample
The smallest reproducible world that still produces the unsafe edge.
Version comparison
How candidate behaviour changes between software or policy versions.
Event replay
A stable scenario identity for investigation and regression review.
Decision proof
A verifiable record of the allowed action selected under that world.
06 / Product maturity
Built foundations. Explicit next steps.
Prototype capability and planned integration are separated so technical ambition never becomes an accidental deployment claim.
Working today
- Calybris Core 1.0.0 with deterministic policy evaluation.
- Hard policy constraints, replay verification and signed decision receipts.
- Python bindings and independent validation work.
- Parametric and counterfactual Calyra scenario prototype.
- Fault injection, failure detection and replay architecture.
Being built next
- CARLA–ROS 2 reference mobility demonstration.
- Campaign tooling for 10,000+ bounded scenarios.
- Replay and event review interface for engineering teams.
- First paid design partnership with a mobility team.
- Controlled-site or hardware-in-the-loop pilot.
07 / Sources & methodology
Numbers with a boundary, not a halo.
The figures on this page are traceable release evidence. They describe a local synthetic benchmark, not road certification or customer production performance.
Calybris Core 1.0.0 benchmark manifest
The manifest records the benchmark profile, run counts, latency percentiles, WAL modes and explicit claim boundaries used here.
Open machine-readable manifestBenchmark and proof-loop plates
Review the published performance plate and the seven-stage proof loop without exposing private scoring weights or adapter internals.
08 / Questions & answers
Calyra, in plain terms.
Short answers for engineering teams, evaluators and answer engines.
What is Calyra Mobility Assurance?
Calyra is a pre-MVP mobility assurance prototype that constructs bounded vehicle scenarios, applies controlled pressure, reduces failures to reproducible counterexamples and preserves replay identity.
Is Calyra a vehicle simulator?
No. Calyra is an assurance layer designed to work with simulation environments such as CARLA, Isaac Sim and Gazebo. The interactive browser lab is an explanatory fixture, not a live simulator.
What does Calybris Core do inside Calyra?
Calybris Core evaluates candidate actions against hard policy constraints, selects an allowed response and preserves the decision as replayable, verifiable evidence.
What public evidence supports this page?
The linked Calybris Core 1.0.0 manifest records local synthetic medians of 4,461,519 kernel decisions per second and 4,188 HTTP requests per second, with 54.052 ms HTTP p99 latency and zero failures across 15,000 measured requests.
Does the browser lab claim road certification or a live CARLA run?
No. It is a deterministic browser-side explanatory fixture. Calyra makes no road-certification, customer-deployment or live remote-simulation claim on this page.
Prefer plain text? Read the English Markdown product overview.
Design partnership / proof of concept