Staff Software Engineer, Backend / Agent Orchestration

Wand Synthesis AI Inc; India; On-site; INR 4,000,000 - 7,000,000; Full time

Job summary

Wand Synthesis AI Inc is hiring a Staff Software Engineer to architect the backend powering a scalable agent orchestration platform. You will work on workflow execution on Temporal, sandboxed agent code, and systems that run thousands of agents with reliability at scale.

You will partner with the India-based team to translate design v3 into working plans, own end-to-end architecture, and ensure robust data pipelines and monitoring.

Qualifications

• Proven experience designing and operating scalable distributed systems.
• Hands-on with Temporal or similar workflow orchestration systems.
• Proficient in Go and Python with deep backend skills.
• Strong knowledge of Kafka, Redis and Kubernetes for data and deployment pipelines.
• Track record owning end-to-end architecture and delivery.
• Experience with agentic/LLM-based systems and tool calling.
• Clear communication and cross-team collaboration.
• Experience building safe, isolated execution environments (sandboxing) is a plus.

Responsibilities

• Architect the agent orchestration and workflow system on Temporal.
• Build task management, autonomous execution loops, and tool calling infra.
• Own distributed data and event pipelines (Kafka, Kubernetes, Redis).
• Turn high-stakes problems into concrete designs and ship them.
• Collaborate with Tech Lead to raise architecture quality and guide teammates.
• Work with Workforce Management and provide production support as needed.

Skills

Distributed systems

Temporal

Kafka

Kubernetes

Go

Python

Architecture ownership

LLM/agentic tech

Tool calling

Communications

Tools

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.