Intent to Execution.
A deterministic visual representation of the Arkhon orchestration layer. Demonstrating asymmetric telemetry routing from the mud boundary to global ground control.
Vesta
Mission Compiler
Caelum
Global Telemetry
Mercury
Air-Gapped Mesh Gateway
Tellus
Rust Edge Kernel
Layer_01 // The Brain
Vesta
Mission Compiler & GCS.
Autonomy is fundamentally decoupled from physical hardware. Vesta absorbs all geometric complexity, generating deterministic JSON Execution Graphs so the edge hardware never has to "think" in the mud.
Two-Tier DAG Compilation
Enforces the Compilation-Execution Divide. Vesta translates macro-intent (40-acre polygons) into a Macro-DAG for logistics, and a Micro-DAG for tight kinematic execution and contingency routing.
Mutable-Ref Digital Twin
Bypasses standard React state to maintain 60FPS WebGL performance. Ingests 10Hz WebSocket telemetry to smoothly render robot odometry and joint kinematics without melting the field laptop's CPU.
Asynchronous HITL via WebRTC
If a robot encounters a semantic exception, Vesta negotiates a sub-200ms WebRTC peer-to-peer connection. It streams an RTSP video feed with overlaid bounding boxes for instant operator resolution.
Layer_02 // The Cloud Backend
Caelum
Enterprise Engine.
We don't sell tractors; we sell guaranteed execution. Caelum is the strict multi-tenant SaaS backend that translates decentralized robotic labor into billable metrics, predictive maintenance alerts, and legally defensible compliance logs.
Dual-Database Architecture
Separates relational business logic (PostgreSQL with strict Row-Level Security) from high-frequency machine telemetry (TimescaleDB Hypertables) for instant dashboard rendering.
Cryptographic Kill Switch
Caelum acts as the sovereign Certificate Authority. If a chassis is stolen, a single API call revokes its mTLS certificate, instantly bricking the hardware and shredding active mission data.
Automated RaaS Metering
Translates 1Hz physical telemetry into financial ledgers. Caelum automatically calculates payload deployment and kinematic usage, pushing idempotent usage records directly to the billing gateway.
- • Tenant Mappings
- • Hardware Registry
- • Billing Ledgers
- • 1Hz Telemetry
- • Sensor Hypertables
- • 1Hr Aggregates
Layer_03 // The Mud Boundary
Mercury
Air-Gapped Mesh Gateway.
Direct-to-cloud robotics fail in the physical world. Mercury is our ruggedized Forward Operating Base (FOB). It translates, throttles, and cryptographically isolates the swarm, ensuring missions execute flawlessly even during total internet blackouts.
Dual-NIC Air Gap
Physical and OS-level isolation. IP forwarding is strictly disabled. The chaotic 50Hz local swarm network (NIC 1) can never physically route to the public cellular WAN (NIC 2).
The Go Multiplexer
A blazingly fast Golang daemon acts as the protocol translator. It ingests local UDP firehoses, handles backpressure by safely dropping packets, and pushes throttled 1Hz gRPC payloads to the cloud.
Crash-Safe Local Persistence
Mercury survives brownouts. Mission DAGs are written to an ACID-compliant embedded B+ Tree (bbolt), while dropped WAN telemetry is cached in an LSM Tree (BadgerDB) for replay on boot.
Zero-Trust TPM Envelope
Mercury is a Subordinate CA. Cryptographic keys live exclusively in volatile RAM. If the chassis is tampered with, a hardware interrupt severs power, evaporating the keys and bricking the device.
ROS 2 Firehose
Compressed Auth
Layer_04 // The Edge Kernel
Tellus
Autonomous Edge OS.
A 10-ton machine running a monolithic workspace is a kinetic liability. Tellus is engineered as a strictly segregated, multi-process operating system that mathematically isolates failure, ensuring the robot survives the physical realities of the farm.
Isolated Blast Radius
Monoliths fail in the mud. Tellus segregates volatile C++ hardware drivers from the immortal Rust orchestrator. If a camera driver segfaults, the OS kills it, but the robot survives and the Rust core instantly resurrects the process.
Zenoh Zero-Copy IPC
Tellus bypasses standard ROS 2 network overhead. Massive data payloads (like 10MB point clouds) are written directly to shared RAM. Isolated processes pass microscopic pointers via Zenoh, achieving sub-millisecond local routing.
The Semantic Bottleneck
Raw sensor data never crosses the IPC boundary. C++ edge nodes violently filter 4K video through TensorRT, extracting only semantic intent. They transmit a microscopic 64-byte FlatBuffer (e.g., 'Target at XYZ') to the Rust brain.
Hardware Agnosticism
The Rust orchestrator calculates intent, not physics. It publishes a generic command ('Navigate to Coordinate'). Interchangeable C++ nodes translate that intent into Ackerman steering for a tractor or quadcopter flight dynamics.