Timing infrastructure for autonomy
Deterministic timing for drone swarms and robotic fleets
Chrono Metrics turns noisy sensor and state streams into a compact, multiscale record of what changed and at what scale — consistent and verifiable across the whole fleet, even when clocks drift and links partition.
Wall-clock time tells you when a sample arrived. Our epsilon-delta-p tick describes how much a system has moved through a metric space. That distinction is what lets two streams at the same sample rate, or one stream with quiet periods and sharp jumps, be compared, indexed, and arbitrated deterministically.
The tick primitive
A gain, an active staircase, and an activation gate. Changes below epsilon stay silent; meaningful changes produce stable integer-like evidence. A ladder runs that comparator at multiple scales, emitting a fixed-width tick vector that is easy to store, compare, index, and feed downstream.
Not wall-clock
Measure change
The tick encodes how far a system moved through a metric space — the right feature when sample rate says nothing about behavior.
Fixed-width code
Multiscale
One deterministic ladder produces a compact vector across resolutions. Quiet periods stay silent; salient jumps land at the right scale.
Arbitrated
Fleet-consistent
Latency compensation, deterministic event ordering, peer reconciliation, and split-brain arbitration to an authoritative quorum.
Replayable
Verifiable
Tamper-evident, hash-chained audit logs and deterministic incident replay for post-mission forensics and certification evidence.
Why timing
Wall-clock time is the wrong feature for autonomy
Clocks tell you when a packet landed. Autonomy stacks need a deterministic answer to a different question: what changed, by how much, and at which scale — across every sensor and every agent.
A non-additive, deterministic measure of movement through metric space. Use clocks for physical time; use Chrono Metrics for measured change.
The ladder evaluates the comparator at several scales at once, so a fine sensor twitch and a coarse trajectory shift land in the right tier.
Bit-identical quantization with golden-vector tests to a 1e-12 tolerance. The same inputs give the same ticks on every node and every run.
One primitive from an MCU to the cloud. Allocation-free hot paths and a C ABI with Python and JS/WASM bindings keep it embeddable on-vehicle.
Calibrated per-tier surprise scoring with escalating Allow → Monitor → Alert → Quarantine policies for sensor health and intrusion signals.
Connectors emit real, parseable wire formats: ROS2, OpenTelemetry, Kafka, Splunk, Datadog, and SCADA — no bespoke glue required.
Open core · Apache-2.0
A small, deterministic primitive you can audit
MetricChrono is a multiscale metric-change ledger. It converts a nonnegative distance — between states, events, embeddings, or signals — into one or more deterministic tick values. It is not a clock, causal model, planner, or controller, and we are explicit about that boundary.
- Small changes stay silent below an explicit epsilon threshold.
- Meaningful changes produce stable integer-like evidence at one or more resolutions.
- The same ladder evaluates from Rust, C, Python, and JavaScript.
- Event logs skip directly between salient changes without losing the full stream.
use metricchrono_core::{
geometric_ladder, ladder_pair, Euclidean, EventLog,
};
let ladder = geometric_ladder(0.5, 1.0, 2.0, 4, 0.5, 1.0)?;
let ticks = ladder_pair(
&[0.0, 0.0][..], &[3.0, 4.0][..],
&Euclidean, &ladder,
)?;
let mut log = EventLog::new(ladder.len())?;
log.append(1_u64, ticks)?;| distance d | tick vector |
|---|---|
| 0.05 | [1, 0, 0] |
| 0.20 | [2, 1, 0] |
| 1.00 | [10, 4, 2] |
| 3.00 | [30, 10, 4] |
Golden three-tier ladder vectors from the published specification.
Open core + Enterprise
Open core for the primitive. Enterprise for the deployment.
The enterprise edition is built on top of the published kernel — it extends the open core by path dependency rather than forking it.
- epsilon-delta-p comparator
- multiscale ladder + tick normalization
- basic metric traits (Euclidean, Cosine, …)
- differentiable smooth surrogate
- stateless adaptive zoom
- in-memory event skip-list index
- minimal one-shot consensus
- Rust / C ABI / Python / JS-WASM bindings
- auto-calibration engine
- domain metric packs (robotics, industrial)
- advanced consensus & reliability engine
- fleet arbitration + incident replay
- persistent, hash-chained audit logs
- security anomaly / OOD policies
- dashboards + cloud service
- OTel · Kafka · Splunk · Datadog · ROS2 · SCADA
Distributed swarm timing
Built for fleets, not single robots
A single deterministic controller ingests every agent's stream, compensates for latency, orders events reproducibly, reconciles peer state, and keeps the swarm converged — then exports the whole episode for replay.
Latency-model correction
Deterministic ingestion with per-stream latency compensation and a quality flag (good / degraded / unknown) on every corrected timestamp.
Deterministic event ordering
A reproducible clock source orders salient events across agents the same way on every node — the prerequisite for fleet-wide agreement.
Peer reconciliation
Peer state and delta exchange with convergence tracking, so agents that fall out of sync are pulled back toward a shared picture.
Source degradation
Healthy → Degraded → Failed transitions with hysteresis, so a flaky sensor or radio link is down-weighted before it corrupts the consensus.
Split-brain arbitration
Two-quorum clustering detects partitioned swarms and arbitrates to the authoritative quorum instead of letting both halves act.
Incident replay
Export and re-import a deterministic replay blob to reconstruct exactly what each agent saw — for debugging, forensics, and certification.
Tamper-evident by default
Salient ticks land in an append-only, SHA-256 hash-chained audit log. Any post-hoc edit breaks the chain, so the timeline you replay is the timeline that happened.
Deployment packs
Pre-wired deployment packs
Each pack fuses a metric, a multiscale change ladder, a timing rhythm, an anomaly policy, and a tamper-evident audit log into one pipeline you can run on day one.
Fleet-consistent timing across many agents, with split-brain arbitration when a link partitions the swarm mid-mission.
SE(2) and SE(3) pose tracking that weights translation and wrapped rotation, surfacing anomalous motion rhythms per vehicle.
A vehicle-perception pack fuses a sensor vector with a fine 1ms–100ms event ladder to flag the rhythm of salient sensor jumps.
Deterministic replay plus hash-chained audit produce defensible evidence of what the system measured and when it reacted.
Integration
How it drops into your stack
Start with the open primitive on a single vehicle, then layer on the enterprise edition as you scale to a fleet.
Drop the Apache-2.0 primitive into your on-vehicle code via Rust, the C ABI, Python, or JS/WASM.
Pick epsilon / delta / p for your metrics by hand, or let the enterprise auto-calibration engine fit them from your data.
Feed ticks into perception and telemetry, and run per-tier anomaly policies for sensor health and OOD signals.
Reconcile across the fleet, arbitrate split-brain partitions, and keep a tamper-evident log you can replay later.
Get started
Book a pilot
We're working with drone-swarm and robotics teams who need fleet-consistent, verifiable timing and want to evaluate MetricChrono against their own sensor streams and failure modes.
- Apache-2.0 open core to start on a single vehicle
- Fleet arbitration, split-brain detection, and incident replay
- Robotics deployment packs (SE(2)/SE(3), perception)
- ROS2 and telemetry connectors