Tech Lead, Robotics Runtime & Middleware

About Mind:

Mind Robotics is building Physical AI for real-world industrial deployment, starting with the factory floor. We believe the hardest problems in AI are solved when researchers and engineers are hands-on with the physical world every day - and we're looking for people who are passionate about robotics, value ownership, and are excited to tackle difficult problems. Join us if you want to move beyond digital intelligence and put intelligence into motion.

The Role:

At Mind Robotics, we're building generalized physical AI — robotic systems capable of dexterous, adaptive, and reasoning-intensive work in real-world industrial environments. That depends on a runtime platform that lets robots perceive, decide, and act under hard real-time constraints.

We're looking for a Tech Lead to lead the development for this runtime: how the robotics and AI modules communicate and execute under tight latency budgets. This is an IC-heavy role: you're in the codebase daily, making the hard latency and correctness tradeoffs yourself, not delegating them.

This is a role for someone who wants to own the hardest problems in real-time robotics software and onboard model serving, and ship them personally.

Responsibilities:

Design and build the robotics runtime/middleware layer – including topic/message architecture, QoS policies, and multi-process communication under tight latency budgets

Own the inference-serving path for onboard models (VLA/action-expert policies): batching, quantization, hardware acceleration, and the tradeoffs between model accuracy and control-loop latency

Architect multi-sensor synchronization and fusion arriving on different clocks and cadences, kept coherent enough for closed-loop control

Make and own the hard technical calls on middleware choice, process/thread architecture, and how much real-time guarantee any given subsystem actually needs

Set technical standards and do deep design/code review across runtime engineering

Prototype and de-risk new architecture directions (new middleware, new compute hardware, new model-serving approaches) before they become team-wide commitments

Work directly with modeling/research to understand what a policy actually needs from the runtime (latency, synchronization, action representation) and make sure the platform delivers it

Requirements:

Strong systems programming in Python and/or Rust

Hands-on experience with robotics middleware — ROS2 (rclcpp/rclpy, DDS implementations like Fast DDS/CycloneDDS, or Zenoh), including designing custom message types, QoS tuning, and multi-node communication patterns

Real-time systems experience: understanding of scheduling, latency budgets, jitter, and the difference between soft and hard real-time guarantees; comfort with RTOS concepts

Experience with embedded/edge Linux — cross-compilation, device driver basics, and resource-constrained execution (CPU/memory/power budgets)

Multi-sensor synchronization: time sync protocols (PTP/gPTP), sensor fusion pipelines, and handling clock drift/skew across distributed compute on a single robot

Model deployment/inference optimization: exporting and running models via ONNX Runtime, TensorRT, or similar; quantization and batching strategies for action-model inference on edge compute; understanding of how model latency translates into control-loop constraints

Experience with control systems and motion primitives — enough to reason about how software architecture decisions (message latency, action chunking, control frequency) affect closed-loop robot behavior

Track record of taking real-time systems from prototype to reliable, continuous operation on physical hardware

Strong technical judgment on tradeoffs between research/experimentation velocity (fast iteration, permissive interfaces) and runtime reliability (determinism, fault tolerance, safety margins)

Comfort making build-vs-buy calls on middleware and compute hardware

Clear communicator who can work directly with research/modeling partners to translate model requirements into runtime architecture, without a layer of translation in between

Nice to Have:

Familiarity with simulation environments (Isaac Sim, MuJoCo, Gazebo) for validating runtime behavior before field deployment

Exposure to functional safety concepts relevant to physical systems

Background in autonomous vehicles, industrial IoT, or other domains with similar real-time/embedded constraints

Experience scaling a runtime platform from a handful of robots to many concurrent units in production

Some prior experience providing technical mentorship or informal lead direction to other engineers, without formal management responsibility