Senior Backend Engineer

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.