Principal Robotics Software Engineer

Weave was founded to build the robots we’d want to have in our own home. We believe the next generation of robotics will transform everyday life by enabling people to do more and to reclaim time to spend on what’s important.

We also believe robots are in a sense like any other product: to matter, they have to ship. Our robots are already operating in real homes and businesses, giving us the opportunity to rapidly improve from real-world experience. With a growing team, strong customer demand, and capital for expansion, we’re entering an exciting stage of growth—and we’re looking for people with exceptional talent and standards to help bring home robotics to millions of households.

As a Principal Robotics Software Engineer, you’ll help define the software architecture that turns the capabilities of a complex robot into coherent, reliable behavior. You’ll work across autonomy, perception, controls, and systems software to determine how independently developed capabilities compose into a robot that can safely pursue goals, respond to a changing world, and recover gracefully when things don’t go as planned.

The behavior and autonomy layer will be at the center of your work. You’ll build the systems that translate high-level goals and evolving robot state into coordinated action, combining learned and classical capabilities while managing uncertainty, competing priorities, failures, and safety constraints. You’ll work closely with domain experts across the robotics stack, and when a systemic problem crosses team boundaries, you’ll follow it wherever it leads.

• Architecture across the stack: Define the interfaces and architectural patterns that allow perception, autonomy, controls, and systems software to compose into reliable robot behavior while remaining modular, debuggable, and extensible.

• Build the behavioral core: Design and build the systems that translate goals and robot state into coordinated action, resolving competing priorities and capabilities as the robot operates in a changing physical environment.

• Enable increasingly intelligent behavior: Develop the infrastructure that allows robots to use context, history, environmental understanding, and user intent to make better decisions over time.

• Own system-level safety: Preconditions, timeouts, fallbacks, and recovery ladders with defined behavior for every way a model or subsystem can misbehave.

• Hunt systemic issues: Latency across module boundaries, timing and resource contention, cascading failures: the problems that belong to no single team land on you, and you resolve them with the domain owners rather than around them.

• Multiply the team: Set interface contracts with the controls, SLAM, and systems engineers who own their domains, review the designs that touch the whole robot, and raise the architectural bar.

• 5+ years building robotics software for robots deployed in the real world, with depth across the stack, from controllers to SLAM to navigation to overall system safety. You’ll have owned at least two of those end-to-end.

• Behavior architecture depth: behavior trees, hierarchical state machines, or task-level executives at production scale, and intuition about an approach’s limits.

• Failure & recovery design: Experience designing systems around partial failure, stale or contradictory state, timeouts, preconditions, interruption, cancellation, retries, and recovery.

• Integrating learned methods: Experience incorporating learned or probabilistic components into larger systems where outputs can be uncertain and overall behavior must remain observable, recoverable, and trustworthy.

• Cross-stack debugging skill: A behavior bug can originate anywhere; you follow it through logs, replay, and other people's code without losing the thread.

• Architecture you can point to: robot systems you designed that other engineers built inside happily, with interfaces that survived years of change.

• Strong C++ and Python and the software habits to keep the most connected component in the stack maintainable.

• Fleet-scale production experience: your behavior code ran on many robots you couldn't watch.

• Experience integrating LLM/VLA-driven behavior into deterministic frameworks.

• Navigation stack experience: planning, costmaps, and recovery behaviors on mobile robots.