Principal Robotics Software Engineer San Francisco, CA · On-site

Weave Robotics, Inc.; San Francisco, Northern (CA, KY); Hybrid; USD 180,000 - 260,000; Full time

Job summary

Weave Robotics, Inc. invites a Principal Robotics Software Engineer to define software architecture across autonomy, perception, controls, and systems software. You will compose independently developed capabilities into reliable robot behavior, enabling safe, goal-driven action in dynamic environments.

You will lead the behavioral core, integrate learned components while maintaining observability, and ensure robust recovery when things don’t go as planned. Strong C++ and Python are essential.

Qualifications

• 5+ years building robotics software for robots deployed in the real world.
• Depth across the stack—from controllers to SLAM to navigation and system safety.
• Experience with behavior architectures at production scale.
• Experience designing systems around partial failure and recovery.
• Experience integrating learned or probabilistic components into deterministic frameworks.
• Strong cross-stack debugging skills and durable interfaces.

Responsibilities

• Define interfaces and architectural patterns for perception, autonomy, controls, and systems software.
• Build the behavioral core translating goals and state into coordinated action.
• Enable intelligent behavior using context, history, and environment understanding.
• Own system-level safety with preconditions, timeouts, and recovery ladders.
• Hunt systemic issues like latency, resource contention, and cascading failures across modules.
• Scale architecture by coordinating with controls, SLAM, and systems engineers.

Skills

Robotics software

C++

Python

System architecture

Behavior trees

Failure & recovery design

Job description

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.