Head of Engineering

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.