SUPERAGENT

Superagent AI is building the AI-native distribution layer for insurance - a $7T industry still run on manual workflows and legacy software. We're an early-stage, fast-moving team reimagining how insurance is sold, serviced, and supported, with AI at the core. Backed by top-tier VCs, we're an international team of exited founders, builders, and technologists.

Already trusted by 100+ agencies, the job now is to build the next version of the platform quickly and run it reliably as we continue to scale rapidly — a real-time voice platform, an agent/skills layer, omnichannel messaging, and deep insurance system integrations.

Why this role exists

Our AI voice agents talk to real policyholders every day, and they're already working — that's why 100+ agencies trust us. What they say, and how reliably they say the right thing, is the product, and we've built real strength here. Now we want to move faster and take it to the next level.

We're hiring a Voice/Conversational AI Engineer to add firepower to how our agents are prompted, evaluated, and improved. You'll design and scale the prompts and agent behaviors behind live calls, mine real call data for the next set of wins, and build the evals and benchmarks that let us push quality forward with speed and confidence. The goal is leverage: ship more improvements, faster, each one backed by evidence rather than guesswork.

This is a hands-on builder role at the intersection of applied AI, data, and product quality — an opportunity to raise an already strong voice platform to a new level.

What you'll own

• Prompt engineering at scale — design, structure, and version the prompts and agent behaviors that drive live voice calls, in a way that stays maintainable as the number of agents and use cases grows.
• Reliability of agent behavior — make the same prompt behave consistently across calls, edge cases, and model updates; catch regressions before customers do.
• Call analysis — dig into real transcripts and call data to find failure patterns, missed intents, and opportunities, and turn those findings into concrete improvements.
• Evals & benchmarks — build the eval harnesses, datasets, and benchmarks that measure agent quality (accuracy, task completion, latency, tone), and make them part of how we ship.
• Data-driven decisions — set the metrics, run the experiments, and bring evidence to every change, so we push quality forward with speed and confidence.
• Velocity through AI-native engineering — you use Claude Code and Codex every day to orchestrate coding agents and raise your leverage, without letting speed erode the reliability bar.

About you (must-haves)

• Strong applied-LLM experience — you've built and shipped LLM-powered features in production, not just prototypes.
• Serious prompt-engineering craft — you can decompose a hard task into reliable prompts/agent steps, and you have opinions on structure, versioning, and keeping prompts maintainable at scale.
• Evals-first mindset — you've built (or badly wished you'd built) eval harnesses, benchmarks, and test sets, and you believe quality is something you measure, not vibe-check.
• Comfortable in data — you can pull, slice, and analyze call/transcript data (SQL and Python/TypeScript) to find signal and quantify impact.
• Solid engineering foundation — you write production code (TypeScript/Node preferred) and can integrate your work into a real backend, not hand it off as a notebook.
• Rigor over intuition — you default to experiments and evidence, and you make the case with data.
• You live in Claude Code / Codex (or equivalent) — fluent and opinionated about AI-assisted engineering. In 2026 we treat this as table stakes.

• Ownership mindset — you own agent quality end-to-end, including in production, and you stay close to how it affects real agencies and their customers.

   

Bonus

• Real-time voice/telephony context (Twilio, SIP, ASR/TTS, latency-sensitive audio) and how it shapes prompting and evals.
• Building agentic systems in production — tools/skills frameworks, MCP, guardrails.
• Fine-tuning, distillation, or eval-driven development at a deeper level.
• Experience building LLM-as-judge or automated grading pipelines.
• Insurance, fintech, or another regulated/compliance-heavy vertical.

Our stack & tools

• Backend: TypeScript, Node, NestJS · monorepo (libs + apps)
• Voice: real-time streaming audio, ASR/TTS, telephony (Twilio / SIP)
• Orchestration: Temporal (Temporal Cloud) for the campaign/workflow engine
• Data: PostgreSQL on AWS RDS (multi-tenant, row-level security)
• AI: Anthropic + OpenAI models, prompt/agent orchestration, evals; fine-tuned/distilled models on our own data
• Frontend: React / Next.js
• Platform: AWS · Clerk (auth) · Datadog (observability) · Pylon + HubSpot (CS/CRM)
• How we ship: Linear (with agent delegation), GitHub, and Claude Code + Codex as part of daily engineering

How we build (engineering principles)

• Reliability is a feature. We don't ship what we can't keep running. The quality bar is non-negotiable.
• AI-native by default. Claude Code, Codex, and coding agents are part of how we work, not a novelty. We expect leverage from them, every day.
• Close to the customer. We prioritize real agency calls and feedback, not opinions in a room.
• Ship small, ship often. Short cycles, fast feedback, evals over guesswork.
• Ownership. Engineers own their work end-to-end - including in production.

How we work

Fast-moving distributed team with an AI-native engineering culture. We're closer to our customers than most competitors - that's our edge, and it drives how we prioritize. We ship things that work for real agencies, not demos.

Superagent AI is building the AI-native distribution layer for insurance - a $7T industry still run on manual workflows and legacy software. We're an early-stage, fast-moving team reimagining how insurance is sold, serviced, and supported, with AI at the core. Backed by top-tier VCs, we're an international team of exited founders, builders, and technologists.

Already trusted by 100+ agencies, the job now is to build the next version of the platform quickly and run it reliably as we continue to scale rapidly — a real-time voice platform, an agent/skills layer, omnichannel messaging, and deep insurance system integrations.

Why this role exists

The product is in production and growing, and the hardest problems now live in the backend. We're bringing on at least two senior backend engineers to take real ownership across our core systems: real-time voice at growing call volume, a Temporal-driven campaign engine, multi-tenant data with strict isolation, and LLM/agent orchestration that has to be reliable.

There's a lot still to build. We're expanding deep into insurance-system and AMS/CRM integrations, and building on frontier AI technologies that most teams don't have access to yet — you'll get your hands on capabilities well before they're widely available. Each of you will own meaningful surface area end-to-end — designing it, building it, shipping it, and keeping it running.

This is a hands-on builder role. You take ambiguous, high-impact problems and turn them into shipped, reliable software. You're trusted to make architecture calls in your area, raise the quality bar, and set an example for how we build as the team scales.

What you'll own

• Shipping backend features end-to-end — from design through production, in one of our pods (Voice/AI, Campaigns + Integrations, or Platform/Reliability).
• Architecture of the systems you touch — event-driven flows, workflow orchestration (Temporal), data models, and the APIs other teams build on.
• Building what's next — new insurance-system and AMS/CRM integrations, plus greenfield work on frontier AI technologies we get early access to before the rest of the market.
• Reliability of what you ship — on-call for your services, SLOs, test automation, and turning flaky things "boring." Reliability is our #1 lever.
• Velocity through AI-native engineering — you use Claude Code and Codex every day to orchestrate coding agents and raise your leverage, without letting speed erode the reliability bar.
• Raising the bar around you — thoughtful code review, pragmatic technical decisions, and mentoring less-experienced engineers.

About you (must-haves)

• 6+ years building production backend software, still hands-on and shipping.
• Strong in TypeScript / Node and comfortable in a NestJS-style monorepo.
• Distributed / event-driven systems — you have specific opinions on queues, backpressure, idempotency, retries, and how services should communicate.
• PostgreSQL depth — schema design, query performance, and an understanding of multi-tenant isolation.
• AWS and production ownership — you've operated what you've built: monitoring, incidents, debugging real issues under load.
• You live in Claude Code / Codex (or equivalent) — fluent and opinionated about AI-assisted engineering. In 2026 we treat this as table stakes.

• Ownership mindset — you own your work end-to-end, including in production, and you're close to how it affects real agencies.

   

Bonus

• Real-time voice / telephony (Twilio, SIP, ASR/TTS, latency-sensitive audio).
• Building agentic systems - tools/skills frameworks, MCP, evals, guardrails - in production.
• Applied LLM work: fine-tuning, distillation, eval-driven development.
• Insurance, fintech, or another regulated/compliance-heavy vertical.

Our stack & tools

• Backend: TypeScript, Node, NestJS · monorepo (libs + apps)
• Orchestration: Temporal (Temporal Cloud) for the campaign/workflow engine
• Data: PostgreSQL on AWS RDS (multi-tenant, row-level security)
• AI: Anthropic + OpenAI models, prompt/agent orchestration, evals; fine-tuned/distilled models on our own data
• Frontend: React / Next.js
• Platform: AWS · Clerk (auth) · Datadog (observability) · Pylon + HubSpot (CS/CRM)
• How we ship: Linear (with agent delegation), GitHub, and Claude Code + Codex as part of daily engineering

How we build (engineering principles)

• Reliability is a feature. We don't ship what we can't keep running. The quality bar is non-negotiable.
• AI-native by default. Claude Code, Codex, and coding agents are part of how we work, not a novelty. We expect leverage from them, every day.
• Close to the customer. We prioritize real agency calls and feedback, not opinions in a room.
• Ship small, ship often. Short cycles, fast feedback, evals over guesswork.
• Ownership. Engineers own their work end-to-end - including in production.

How we work

Fast-moving distributed team with an AI-native engineering culture. We're closer to our customers than most competitors - that's our edge, and it drives how we prioritize. We ship things that work for real agencies, not demos.

Superagent AI is building the AI-native distribution layer for insurance - a $7T industry still run on manual workflows and legacy software. We're an early-stage, fast-moving team reimagining how insurance is sold, serviced, and supported, with AI at the core. Backed by top-tier VCs, we're an international team of exited founders, builders, and technologists.

Already trusted by 100+ agencies, the job now is to build the next version of the platform quickly and run it reliably as we continue to scale rapidly — a real-time voice platform, an agent/skills layer, omnichannel messaging, and deep insurance system integrations.

Why this role exists

Our founder is a hands-on technical CTO and the product owner (CPO) - 13+ years in engineering, hundreds of hours with customers, and a strong view on what we build and why. As we grow, the founder is moving toward customers, the CS team, product/design, and the occasional deep technical build - and needs a Head of Engineering who owns building the product day-to-day and runs the team.

This is a builder-leader role. You are responsible for shipping the actual product: you own engineering execution, most of the architecture, the quality bar, and the team. The CTO sets product direction and priorities and stays close to the hardest technical problems; you own turning that into shipped, reliable software with a team you build and grow. If you want to own building a sophisticated AI product end-to-end, it is your seat.

Why now - the opportunity

You'd be our first dedicated engineering leader, joining at a moment when the product has proven itself and the work shifts to scaling it. You're not staring at a blank page - you inherit a working product, paying customers, and a rare data asset. What you get to build is the engineering org: grow the team, define the pod and tech-lead structure, set how we ship, and shape the engineering culture from the ground up. It's a genuine 0→1 leadership canvas on top of a 1→N product, with a clear path to VP Engineering as we grow.

What you'll own

• Building the product. You own the engineering output - architecture, technical decisions, and shipping. Hands-on enough to design the hard parts and review the critical code, not a hands-off manager.
• The team. Manage, coach, hire, and grow engineers, organized into focused pods with tech leads (Voice/AI, Campaigns + Integrations, Platform/Reliability).
• Reliability & quality — our #1 lever. You own the release gate, on-call, incident response, and driving reliability from "firefighting" to "boring." This is the outcome we judge first.
• Velocity through AI-native engineering. We run an AI-first engineering org. You and the team ship with Claude Code and Codex every day - orchestrating coding agents, not hand-typing everything - and you raise the whole team's leverage with them while never letting speed erode the reliability bar.
• Execution partnership with the Product Designer (peer under the CTO) to scope, sequence, and ship.

About you (must-haves)

• People management is non-negotiable. 3+ years directly leading engineers as an EM / Head of Eng / Director - hiring, growing, retaining, and building pod/tech-lead structure as a team scale. We will dig into this hard.
• 8+ years building production software, and still hands-on - you architect and build the hard parts, not just review.
• You live in Claude Code / Codex. Daily, fluent, opinionated about AI-assisted engineering. In 2026 we consider this table stakes for an eng leader; if you're not orchestrating coding agents as a core part of how you and your team ship, this isn't the right fit.
• Owned reliability for a system real customers depend on - on-call, incidents, SLOs, test automation - and made something flaky boring.
• Strong in our domain of engineering: TypeScript/Node, distributed/event-driven systems, a workflow engine (we use Temporal), PostgreSQL, AWS, multi-tenant architecture. Bonus weight for real-time voice/telephony and production LLM/agent systems.
• High-load / distributed systems. You've designed and operated systems at real scale and have strong, specific opinions: high-throughput event-driven and streaming architectures, queues and backpressure, idempotency, horizontal scaling of stateful real-time workloads, latency budgets, and capacity planning. You think clearly about how services should communicate and what to reach for, and why. We're a real-time voice platform with growing call volume and millions of traces.
• Can architect at the infrastructure level. You don't run DevOps day-to-day (we have a DevOps engineer for that), but you design at that level and make the calls: autoscaling strategy (e.g. HPA vs KEDA), container orchestration, cost/performance trade-offs, observability at scale. You own the infra architecture direction and partner with DevOps on execution.

• Thrives under a hands-on technical founder - you've done it, or can clearly say why it energizes rather than frustrates you. The CTO will be in the code on the hard problems; the right person treats that as a multiplier.

   

Bonus

• Real-time voice / telephony (Twilio, SIP, ASR/TTS, latency-sensitive audio).
• Building agentic systems - tools/skills frameworks, MCP, evals, guardrails - in production.
• Applied LLM work: fine-tuning, distillation, eval-driven development.
• Insurance, fintech, or another regulated/compliance-heavy vertical.

Our stack & tools

• Backend: TypeScript, Node, NestJS · monorepo (libs + apps)
• Orchestration: Temporal (Temporal Cloud) for the campaign/workflow engine
• Data: PostgreSQL on AWS RDS (multi-tenant, row-level security)
• AI: Anthropic + OpenAI models, prompt/agent orchestration, evals; fine-tuned/distilled models on our own data
• Frontend: React / Next.js
• Platform: AWS · Clerk (auth) · Datadog (observability) · Pylon + HubSpot (CS/CRM)
• How we ship: Linear (with agent delegation), GitHub, and Claude Code + Codex as part of daily engineering

How we build (engineering principles)

• Reliability is a feature. We don't ship what we can't keep running. The quality bar is non-negotiable.
• AI-native by default. Claude Code, Codex, and coding agents are part of how we work, not a novelty. We expect leverage from them, every day.
• Close to the customer. We prioritize real agency calls and feedback, not opinions in a room.
• Ship small, ship often. Short cycles, fast feedback, evals over guesswork.
• Ownership. Engineers own their work end-to-end - including in production.

At least 4h overlap with PST business hours is required.

How we work

Fast-moving distributed team with an AI-native engineering culture. We're closer to our customers than most competitors - that's our edge, and it drives how we prioritize. We ship things that work for real agencies, not demos.