Open position · Hardware Agent Engineering
Most software talks to other software. You build the layer where AI agents meet the physical world — sensors, actuators, protocols, and the hard real-time constraints that come with systems that can't crash gracefully.
The role
Agents that live entirely in software have a clean life. Your agents don't. They read from sensors that drift, write to actuators that wear, operate on buses that drop packets, and run on compute that sits inside machines operating in warehouses, streets, and hospitals. You build the software layer that makes AI agents physically capable — reliable, safe, and aware of the constraints that matter when the consequence of a bad output isn't a wrong answer, but a physical action in the world.
This role sits at the intersection of embedded systems, robotics middleware, and agent architecture. You'll design the interfaces, protocols, and runtime systems that let high-level agent intelligence reach down and do things. You'll work closely with Field Technicians who maintain what you build, and HITL Operators who step in when your systems reach their limits. The feedback loop is tight and the stakes are real.
What you'll do
Hardware abstraction & interfaces
Design and implement hardware abstraction layers that expose physical devices as clean agent-addressable APIs
Write drivers and interface code for sensors, actuators, cameras, LiDARs, and communication modules
Implement hardware communication protocols — CAN bus, I²C, SPI, UART, USB, and Ethernet variants
Build sensor fusion pipelines that give agents a coherent, reliable view of physical state
Agent runtime systems
Develop real-time agent execution environments that meet the latency and determinism requirements of physical systems
Build tool-use interfaces that let LLM-based agents invoke hardware actions safely and with appropriate constraints
Design state machines and supervisory controllers that enforce safety envelopes around agent decisions
Implement watchdog systems, emergency stops, and graceful degradation for when agents operate at the edge of their competence
Safety & reliability
Define and enforce hardware-level safety constraints that agent instructions cannot override
Build comprehensive fault detection — sensor failure, communication loss, actuator degradation
Design and run hardware-in-the-loop test suites for new agent capabilities before field deployment
Instrument systems for observability — every agent action and hardware response should be logged and attributable
Fleet infrastructure
Build OTA update pipelines for firmware and agent software across distributed hardware fleets
Develop remote diagnostics tools that Field Technicians use to investigate hardware issues without physical access
Design configuration management systems for heterogeneous hardware across deployment environments
Contribute to hardware selection and integration decisions for new fleet deployments
Hardware surfaces we're building for
Robotic arms & AMRs
Manipulation, locomotion, payload control
Drone platforms
Flight control, payload, comms, safety
Sensor arrays
LiDAR, RGBD, IMU, environmental sensors
Autonomous vehicles
Drive-by-wire, perception stack, safety systems
Industrial automation
PLCs, conveyors, pick-and-place, vision systems
Edge compute nodes
Smart city infrastructure, embedded AI hardware
What we're looking for
Must-haves
Strong systems programming in C, C++, or Rust — you write code that runs close to the metal
Hands-on experience with embedded systems, robotics hardware, or industrial automation
Familiarity with hardware communication protocols: CAN, I²C, SPI, UART, or similar
Comfort with real-time constraints — you reason about latency, jitter, and determinism
Strong debugging instincts at the hardware/software boundary — oscilloscopes and logic analyzers are tools, not mysteries
Nice-to-haves
Experience with ROS 2 or similar robotics middleware
Familiarity with LLM tool-use patterns and agentic frameworks
Background in functional safety standards (ISO 26262, IEC 61508, or similar)
Python fluency for tooling, test automation, and agent-side integration work
Technical stack
We work across a heterogeneous hardware landscape — no single stack dominates, and you'll need to move between them. What's non-negotiable is the ability to work at the boundary between software and physical reality: to read a datasheet, write a driver, measure a signal, and trace a fault from agent decision to hardware output and back.