Principal Robotics Software Engineer

Socket.dev; San Francisco (CA); On-site; USD 180,000 - 260,000; Full time

Job summary

Weave is seeking a Principal Robotics Software Engineer to define the software architecture that turns complex robot capabilities into reliable, safe behavior. You’ll work across autonomy, perception, controls, and systems software, building the behavioral core and ensuring coordination among diverse components.

You will collaborate with domain experts to manage uncertainty, safety constraints, and runtime failures, while scaling behavior across fleets of robots.

Qualifications

• 5+ years building robotics software deployed in real-world robots.
• Behavior architecture depth: behavior trees, hierarchical/state machines at production scale.
• Failure & recovery design: handle partial failures, timeouts, retries, and safe fallback.
• Integrating learned methods: blend learned components with deterministic systems.
• Cross-stack debugging: tracing bugs across modules via logs and replay.
• Architecture you can point to: robust interfaces that survived years of change.
• Strong C++ and Python coding habits to keep the biggest stack component maintainable.

Responsibilities

• Define interfaces and patterns across perception, autonomy, controls, and systems software.
• Build the behavioral core translating goals/state into coordinated robot action.
• Enable intelligent behavior using context, history, and user intent.
• Own system-level safety including preconditions, timeouts, fallbacks, and recovery ladders.
• Identify and resolve systemic issues like latency and resource contention across modules.
• Collaborate with controls, SLAM, and systems engineers to raise architectural standards.

Skills

Robotics software

C++

Python

Behavior trees

State machines

System safety

Cross-stack debugging

Tools

ROS

SLAM

Navigation stack

Job description

Join Us, and Ship Robots

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.

The Role

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.

Responsibilities

• 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.

What You'll Bring

• 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.

Nice to Have

• 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.