Staff AI Infrastructure Engineer
Cassi · United States ·
- Seniority
- Staff
- Category
- Devops
- Experience
- 3+ years
Cassi · United States ·
algo1 · London
stord · Remote - TX
withwisdom · Remote
Cobre · LATAM
Cassi, a startup building an intelligent home/property automation platform, wants a Staff/Principal engineer to own its AI intelligence layer end to end: the agent runtime, multi-provider inference infrastructure, realtime voice, RAG retrieval, and evaluation/observability. The stack is TypeScript end to end on AWS with DynamoDB and PostgreSQL.
Own the intelligence layer - the agent runtime, the inference substrate beneath it, and how that capability becomes product. Audit what exists; build what scales.
Cassi is a fast-growing startup building an intelligent home automation platform that enables property managers, service providers, and homeowners to easily maintain and operate a property (and more). We're a small team shipping real product daily - SOC2 compliant, event-driven, and built to scale.
The intelligence layer isn't a feature bolted onto that platform; it's increasingly how the platform works. Voice and chat agents that take real action on a property, retrieval over years of asset and service history, and ambient intelligence that surfaces what a property manager should look at before they think to ask.
We're looking for a Staff- or Principal-level engineer to own our intelligence layer end to end - the agent runtime, the multi-provider inference infrastructure underneath it, and the surfaces where that capability reaches real users.
Two things this role is not. It isn't a research role: everything you build ships to production and someone depends on it that week. And it isn't prompt-tuning: the hard problems here are systems problems - streaming, tool-call correctness, retrieval quality, authorization inside an agent loop, evaluation of non-deterministic behavior, and the unit economics of inference at scale.
It's also explicitly a productization role. Capability that only exists in a graph isn't worth much. You'll drive how intelligence shows up across customer-facing product and in the internal tooling our own team runs the business on.
Read the stack named below as current state, not as a specification. It was built fast, by a small team, under real deadlines and a meaningful part of this role is auditing those choices and deciding which of them deserve to survive contact with scale. If the provider abstraction is leaky, if the retrieval design won't hold at ten times the corpus, if a graph is doing work that belongs in a deterministic service. We want to hear that argued with evidence, and then we want you to lead the rebuild. You'll own the problem space, hold real architectural authority over it, and lead by example.
You'll take primary ownership of a couple of these and contribute across all of them. Each describes where the system stands today and the problem it exists to solve , not a design you're inheriting unchanged.
Architectural Audit & Scale
prior art · load-bearing decisions · migration paths A standing mandate that cuts across everything below. Much of the intelligence layer was built at startup speed to prove a thesis, and it did. Now it needs to hold at many times the current volume, corpus size, and concurrency. You'll pressure-test the existing design choices, distinguish the ones that were right from the ones that were merely first, and own the migrations including the unglamorous part where users are still on the old path while the new one comes up.
Agent Runtime & Orchestration
graph orchestration · sub-agent delegation · authorized tool surface Our agents run as orchestration graphs - a voice runtime, a context planner, and an ambient signal runtime - with sub-agent delegation and a tool surface spanning properties, jobs, calendar, assets, and reporting. You'll own graph topology, tool-call correctness, multi-turn state, and what happens on partial failure or a model that confidently calls the wrong thing.
Inference Infrastructure & Model Routing
multi-provider inference · three vendors · streaming + failover A provider-agnostic substrate sits behind a single internal interface, so a model swap is a config change rather than a rewrite. You'll own that abstraction: streaming, failover, routing by cost/latency/capability, provider-native usage normalization, and keeping vendor coupling reversible as the model landscape shifts under us.
Realtime Voice
bidirectional streaming audio · session metrics Live voice sessions between people and the platform: session lifecycle, interruption and barge-in, latency budgets where every hundred milliseconds is audible, and normalizing provider-native usage into billable audio units we can actually reconcile.
Retrieval, Context & Memory
vector retrieval · RAG · per-property context What the model sees is the product. You'll own embedding and chunking strategy, vector retrieval over property, asset, and document corpora, the context assembler deciding what enters a given window, and durable per-property memory that accumulates across interactions.
Ambient Intelligence & Evaluators
event-driven spine · evaluators · signal generation Intelligence that runs unprompted off our event spine - evaluators over assets, jobs, and service history that decide when the system should raise something on its own. The interesting constraint is restraint: a system that speaks up too often gets muted, and a muted system is worthless.
Evaluation, Observability & Unit Economics
eval harnesses · agent tracing · cost attribution The discipline that keeps the rest honest. Eval harnesses and quality-regression gates for behavior that isn't deterministic, end-to-end agent tracing operators can actually debug, and token/audio/cost attribution per organization and per feature so we know what each capability costs to serve.
Productization — In-Product and Internal
copilot surfaces · insights · internal ops agents Turning capability into things people use: assistant surfaces in the product, generated insights and recommendations, and internal agents that make our own small team operate like a larger one. New user-visible surfaces ship dark behind feature gates, so you'll be comfortable separating deploy from release.
Two separate clocks run here, and we state them separately on purpose. The Staff/Principal bar is about systems design and architecture, which takes years to build. LLM experience is capped by how long the technology has actually been in market.
8+ years of professional backend engineering
This is the Staff/Principal half, and it's about systems: service boundaries, failure modes, data modeling for access patterns, and the architectural judgment to own a layer rather than a feature. Most of this experience will predate LLMs entirely, and that's the point - the hard problems in this role are distributed-systems problems wearing a new hat.
Roughly 3–5 years working directly with LLMs
What we're actually looking for is someone who has shipped through several model generations and holds opinions that were formed by being wrong at least once.
Production experience, not demos
You've shipped an agentic or generative feature, watched it behave badly in ways the prototype never did, and fixed the system rather than the prompt. If your LLM time is shorter than the range above but all of it was spent operating something real, tell us - we'd rather have three deep years than six adjacent ones.
TypeScript mastery
Our intelligence layer is TypeScript end to end. You're comfortable with branded types, generics, strict mode, and the type system as a design tool, including for typing tool schemas and structured model output.
Agent and tool-calling depth
Orchestration graphs or state machines, tool/function schema design, multi-turn state, structured output, and sane behavior under retries, timeouts, and partial failure.
Inference fundamentals
Streaming, context-window management, tokenization, prompt caching, sampling parameters, and a real feel for the latency/cost/quality tradeoff rather than reaching for the largest model by default.
Retrieval judgment
Embeddings, chunking, vector and hybrid search, relevance evaluation, and the judgment to know when retrieval is the wrong tool and a direct query or a deterministic path is better.
Evaluation discipline
This is the differentiator for us. You treat "it seems better" as a hypothesis, not a result. Offline and online evals, LLM-as-judge and its limits, and detecting regressions in a system that returns something different every run.
Security instinct for AI surfaces
An agent that can call tools is an authorization surface. Every tool call in our system runs through the same permission model as a human request, and you should find that obviously correct. Prompt injection, data exfiltration, and multi-tenant isolation are your problems, not someone else's review checklist.
Judgment about other people's architecture
You can inherit an existing system, assess it honestly, and tell the difference between a design that's wrong and a design that's merely unfamiliar. You've argued for a rewrite with evidence, argued against one when extending was the better call, and run at least one migration while production traffic stayed on the old path.
Backend depth
You've built services, not just endpoints. Experience with DDD, event-driven architecture, or clean architecture patterns. You understand why service boundaries matter.
Database fluency
Comfortable with both NoSQL (DynamoDB) and relational (PostgreSQL). You can model data for the access pattern, not just the entity.
Move fast, ship quality
You can take a feature from concept to production in days, not sprints. You handle errors and think about failure modes. Testing is a first-class citizen, including the harder question of how you test something non-deterministic. Build for today, architect for tomorrow.
productboard · Prague, CZE