Staff Software Engineer, Backend / Agent Orchestration

Wand Synthesis AI Inc; United States; Remote; USD 180,000 - 240,000; Full time

Job summary

Wand Synthesis AI Inc is seeking a Staff Software Engineer to architect the distributed backend that powers agent orchestration. The role focuses on workflow execution on Temporal, sandboxed agent code, and scalable pipelines to support thousands of agents.

You will pair with the India-based Tech Lead to turn design v3 into a concrete plan and guide the team in building it, emphasizing orchestration, task execution, tool calling, and sandboxing in a large-scale distributed system.

Qualifications

• Real scalable distributed systems experience across multiple machines.
• Hands-on with Temporal or comparable workflow orchestration systems.
• Strong with Kafka and Kubernetes for container orchestration, especially sandboxing components.
• Deep backend expertise with no frontend; backend-first scope.
• Experience with distributed streaming and event-driven systems (Kafka/Redis).
• Track record of owning architecture end-to-end.

Responsibilities

• Architect the agent orchestration and workflow execution system on Temporal, including sandboxing for safe code execution.
• Build task management, autonomous execution loops, and tool calling infrastructure for real-world-scale agents.
• Own distributed data and event pipelines (Kafka, Kubernetes, Redis) to ensure observability and resilience.
• Translate high-stakes problems into concrete technical designs and ship them with documentation.
• Pair with the Tech Lead to raise the bar on architecture and code quality across the team.
• Collaborate with Workforce Management to align execution layer with top-level workflows and provide production support.

Skills

Distributed systems

Temporal

Kafka

Kubernetes

Go

Python

Architecture ownership

Clear communicator

Agentic/LLM tool calling

Tools

Redis

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.