We build AI products for production workloads: multi-agent systems, RAG platforms, real-time inference pipelines, and an MCP-based LLM agent platform running on Kubernetes. We are hiring a senior AI engineer — a strong Python backend developer whose center of gravity is LLM systems — into the team, not onto a single project, to own these systems from architecture to production.
The role:
You design and build the systems that turn LLMs into reliable features: agent orchestration, RAG pipelines, inference APIs, eval harnesses. Some of the work is protocol-level — MCP sessions, JSON-RPC, streaming, cancellation across network hops — with no framework between you and the model; some of it is LangGraph flows, retrieval pipelines, and event-driven services on AWS. You take work from a problem statement to production: scope it, build the critical pieces, instrument it, and stay responsible for how it behaves under load.
This is a role for someone who works independently. You make decisions, write them down, and verify your own work before anyone else has to. Nobody assigns you subtasks. You own your services in production end to end; there is no separate ops hand-off.
What we look for:
Maturity and self-direction first. Several years shipping non-trivial Python backends to production and staying responsible for them afterwards. You take a problem statement, reconcile it against the code, scope it, ship it — and you can talk about something you built that broke, and how it changed your design taste.
The AI engineering core
LLM application patterns: tool use, structured output, streaming, retries, fallback. You have built at least one non-toy agent or RAG system end to end — and you are comfortable both with a framework (LangGraph or similar) and without one, hand-building the loop at the API level.
RAG in production: chunking, hybrid search, reranking, vector databases (pgvector or dedicated stores) under real traffic — with retrieval quality you can measure.
Evaluation: you treat evals as the way you know a change worked, not as a deliverable for a slide.
Cost-aware AI architecture: batching, caching, token budgeting, graceful degradation when a provider fails or a budget runs out.
LLM security awareness: prompt-injection and data-exfiltration thinking whenever a model sits between users and data.
LLM serving and MLOps working knowledge: enough vLLM / Hugging Face exposure to get a model behind an API; model versioning and experiment tracking (MLflow, W&B) are a plus.
AI tooling in your own workflow (Claude Code, Cursor, agents, evals): you know where it helps and where it costs you correctness if you trust it too far.
The platform fluency that carries it
Strong async Python: FastAPI (or equivalent), Pydantic v2, asyncio, background workers (Celery, ARQ, or similar). Streaming pipelines, bounded concurrency, cancellation and timeout topologies across network hops.
Data layer judgement: PostgreSQL at scale (pgvector, JSONB, partitioning), Redis beyond a cache, event-driven coordination (Kafka, Redis Streams), idempotency and multi-replica-safe state enforced at the database level.
High-load experience: you have operated systems under real traffic and know where they tend to fail first.
Hands-on AWS and real Kubernetes fluency beyond deploys: choosing between AWS primitives on their own merits; RBAC, services and labels as an API contract; secrets; debugging a failing rollout yourself.
Observability mindset: tracing, structured logs, metrics that someone actually pages on. OpenTelemetry experience is welcome.
Security: secrets handling, multi-tenant isolation, service-to-service auth (JWT, JWKS, OAuth) — and the judgement to know which edges must fail closed.
How you work
Delivery discipline: you scope, plan, and ship on a predictable cadence. You write a spec or an ADR when the problem warrants it, and you can tell the difference.
Mentoring: you have helped other engineers grow through review and pairing. You ex
