Job VC

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.