Physical AI & Robotics

Robotic agents need more than fast telemetry. They need a memory of what the robot observed, what action was taken, which context was retrieved, and what happened afterward. ZeptoDB keeps the high-frequency sensor timeline and the agent memory timeline together.

---

Why Physical AI teams choose ZeptoDB

522ns to tensor

Zero-copy path from column store to NumPy and PyTorch. Online inference and offline training share the same SQL and the same data.

Nanosecond ASOF JOIN

Time-align heterogeneous streams — LiDAR, stereo cameras, IMU, tactile, proprioception — with nanosecond precision. Point-in-time correct, always.

5.52M events/sec

Ingest 10KHz+ sensors from a fleet of robots without backpressure. Lock-free MPMC ring buffer, zero allocation on the hot path.

Episodes on S3

Replay petabyte-scale Parquet episodes for offline RL training, imitation learning, and regression tests. Hot + cold in one query.

Action memory

Store retrieved context, operator interventions, policy notes, tool calls, and action outcomes beside the raw sensor stream.

---

Where it fits in the stack

Sensor fusion for perception

• ASOF JOIN across LiDAR point clouds, camera frames, IMU, and depth streams
• Window JOIN with ±N ms tolerance for clock drift across heterogeneous buses
• Nanosecond-precision timestamps end-to-end — parser to column store

Feature store for RL and imitation learning

• Rolling statistics (EMA, stddev, percentiles) computed in SQL at query time
• Zero-copy NumPy / PyTorch handoff for online inference loops
• Parquet HDB replay for offline training with the exact same feature definitions

Fleet telemetry & diagnostics

• Ingest telemetry from thousands of robots or drones simultaneously
• Real-time anomaly detection with window functions — motor current, joint torque, battery
• Historical forensics from Parquet HDB when something goes wrong in the field

Sim-to-real evaluation

• Treat simulation rollouts and real-robot episodes as the same schema
• Compare policy performance across batches with standard SQL aggregates
• Versioned datasets via immutable Parquet snapshots

Agent memory for robot behavior

• Store memory records for failed grasps, successful recoveries, operator corrections, and safety interventions
• Retrieve similar episodes before an agent chooses a plan
• Replay the chain from sensor data to retrieved context to action outcome
• Cache repeated diagnostic responses during fleet operations

---

Example: sensor fusion pipeline

-- Align LiDAR scans with the most recent IMU sample and camera frame
SELECT
    l.ts,
    l.point_cloud,
    i.accel_x, i.accel_y, i.accel_z,
    i.gyro_x,  i.gyro_y,  i.gyro_z,
    c.frame_id
FROM lidar_scans l
ASOF JOIN imu_readings  i ON l.robot_id = i.robot_id AND l.ts >= i.ts
ASOF JOIN camera_frames c ON l.robot_id = c.robot_id AND l.ts >= c.ts
WHERE l.ts > now() - interval '10 seconds'

import zeptodb
import torch

conn = zeptodb.connect("localhost:8123")

# Query → NumPy → Tensor in microseconds, no serialization
result = conn.query(
    "SELECT accel_x, accel_y, accel_z FROM imu_readings WHERE ts > now()-1s"
)
tensor = torch.from_numpy(result.to_numpy())  # zero-copy view

---

Integration points

System	Integration
ROS2	Planned plugin — direct topic subscription, message-type-aware columns
MQTT	Ingestion connector for lightweight robot telemetry
OPC-UA	Industrial connector for co-bot and fixed-robot cells
PyTorch / JAX	Zero-copy via NumPy bridge
Arrow Flight	Batch streaming for distributed training
Parquet on S3	Immutable episode storage for dataset versioning

---

Why this matters commercially

Physical AI teams routinely assemble Kafka, Parquet, Redis, vector search, and a custom ASOF-JOIN service, then spend quarters keeping the stack coherent. ZeptoDB collapses the hot path into one operational model: raw sensor facts, temporal joins, agent memory, cache lookup, and replayable AgentOps telemetry.

Talk to us about your pipeline: Contact Sales →