Staff Software Engineer, Backend / Agent Orchestration

Wand AI; Palo Alto (CA); On-site; USD 220,000 - 300,000; Full time

Job summary

Wand AI is hiring a Staff Software Engineer to architect the distributed backend powering agent orchestration. You will design and implement workflow execution on Temporal, sandboxed agent code, and scalable pipelines that run thousands of agents with high reliability.

You will partner with the India-based team lead to translate design v3 into a real plan and execute it. This role emphasizes deep backend work, orchestration depth, and strong communication, with a focus on safety and scale.

Qualifications

• Experience with distributed systems across many machines.
• Proficient with Temporal or similar workflow systems.
• Strong knowledge of Kafka and Kubernetes for container orchestration.
• Deep backend development skills.
• Experience with distributed streaming and event-driven systems (Kafka, Redis).
• End-to-end architecture ownership and decision-making.
• Proficiency in Go and Python.
• Clear communication and ability to lead design independently.
• Exposure to agentic or LLM-based systems, especially tool calling.

Responsibilities

• Architect the agent orchestration and workflow system on Temporal, including sandboxing for safe code execution.
• Build task management, autonomous execution loops, and tool-calling infrastructure for scalable agent actions.
• Own distributed data and event pipelines (Kafka, Kubernetes, Redis) to ensure observability and resilience.
• Turn complex problems into concrete designs, ship them, and document architecture for future engineers.
• Collaborate with Tech Lead to raise architecture and code quality across the team as it scales.
• Support Workforce Management integration and production readiness, including US-afternoon coverage.

Skills

Go

Python

Distributed systems

Architectural ownership

Communication

Tools

Temporal

Kafka

Kubernetes

Redis

Sandboxing

Job description

Build the Future Workforce

Wand turns AI into labor. It enables humans and AI agents to operate together as a unified, hybrid workforce, with comprehensive management and oversight. And it’s already operating at scale inside some of the world’s largest organizations.

Wand built the world’s first Agentic Labor Infrastructure enabling governments and global enterprises to create, manage, and scale digital workforces.

Our mission is to integrate agent ecosystems into the core of work and business, unlocking a generational leap in the global economy. We’re building the infrastructure that lets humans and AI agents operate together safely, transparently, and at scale.

Join Wand in leading the Agentic Shift

Wand is building a high-performing global team who take full ownership of what they build. We lead by example, move fast, make data-aware decisions, and continuously push for more- always with a focus on delivering real value to customers.

You would be joining a world-class team that combines deep research expertise and real-world product execution, with experience spanning Deepmind, Google, Amazon, Miro, Elise AI, IBM and Accern.

Position Summary

Every agent on our platform runs because of what this team builds. We're hiring a Staff Software Engineer to help architect the distributed backend that powers agent orchestration at Wand: workflow execution on Temporal, sandboxed agent code, and the pipelines that keep thousands of agents running without falling over. Zero UI, zero fluff. Just hard distributed systems problems at real scale.

You’ll pair directly with our Tech Lead on the India based team and take the architecture to the next level. We need someone who can turn “design v3 of this system” into a real, working plan, then help the team build it.

This isn’t just about orchestrating a single agent. It's about orchestrating a workforce of agents working together through processes, and building the layer that makes that possible. Orchestration, task execution and tool calling, and sandboxing are largely independent pieces, so depth in any one of them matters more than breadth across all of them.

Role Responsibilities

• Architect the agent orchestration and workflow execution system on Temporal, including the sandboxing that keeps agent code execution, web access, and file systems locked down and safe.
• Build the task management, autonomous execution loops, and tool calling infrastructure that let agents run independently and act in the real world at scale.
• Own the distributed data and event pipelines (Kafka, Kubernetes, Redis) that keep the platform observable and resilient.
• Turn ambiguous, high stakes problems into concrete technical designs, ship them, and document the architecture so the next engineer doesn't have to guess.
• Pair with the team's Tech Lead to raise the bar on architecture and code quality, reviewing designs across the team as it scales.
• Work with the Workforce Management team so the execution layer supports what they're building on top, and pitch in on production support, including coverage that overlaps with US afternoons.

Key Requirements

• Real scalable distributed systems experience: production systems that run across many machines, not one box.
• Hands on with Temporal or comparable workflow orchestration systems.
• Strong with Kafka, and Kubernetes for container orchestration (especially for the sandboxing components).
• Deep backend chops. There's no frontend here, so this needs to run deep.
• Experience with distributed streaming and event driven systems (we use Kafka and Redis). What you built with these tools matters more than which specific ones you've used.
• A track record of owning architecture end to end, not just contributing to someone else's plan.
• Strong in Go and Python.
• Clear communicator who can design independently and bring the team along.
• Exposure to agentic or LLM based systems, especially tool calling.

Preferred Experience

• Experience building safe, isolated execution environments (sandboxing).
• Background in process automation or RPA (e.g. BPMN, Camunda, UiPath, or similar), even without direct agent experience. We're building orchestration for a workforce of agents, and process automation experience transfers well.
• Exposure to distributed data stores such as Cassandra or ClickHouse. Helpful, not required.
• Experience building infrastructure other teams can't live without.
• On call experience for distributed systems.
• Time spent scaling infrastructure inside a fast growing engineering org.