What you will doWe're hiring infrastructure engineers who like hard distributed-systems problems and want to own them end to end. Here's some of what you might work on with us:
- Agentic infrastructure. Our agents don't answer a question and disappear. They take on units of work that run for hours or days, change hands, and continue to drive work to completion. We build the runtime that creates continuity for that work: long-running sessions that survive failures, durable workflow state, lifecycle and cancellation, and workflows that track each piece of work to completion across every stage and every party involved.
- Context architecture. Because work flows through our platform, we're present when the connections between code, tickets, units of work, and past decisions are made. The context between these systems of record is necessary for the agent to do its work well, and the data models behind it shape everything an agent can know. We design how that context is represented and delivered: what gets precomputed ahead of time versus resolved on demand, and how the right slice reaches each agent at the right moment.
- The communication layer. Real work doesn't happen in isolation. Agents work alongside other agents (subagents, teammates, agents on customer machines, agents over MCP) and alongside people. We're building the layer that connects them: messaging between agents within and across sessions, escalations that pull in the right person at the right time, and agents that can be interrupted when new information arrives.
- Sandboxes and fleets. An organization's work is spread across laptops, QA fleets, production hosts, and ephemeral scripts. We build our own sandbox infrastructure, environments that spin up instantly and run by the hundreds, plus a fleet layer that lets agents work on the machines where customer work already happens.
What you bring- A builder mindset. You own projects end to end, think carefully about data models, performance, and maintainability, and have taken prototypes to production with a clear sense of the reliability and scale tradeoffs.
- 3-5+ years building backend systems, ideally real-time, stateful, or event-driven workloads, with strong distributed systems fundamentals: message queues (Kafka, Pulsar), distributed locks, pub/sub, and their failure modes.
- Experience building infrastructure for LLMs in production: tool calling, streaming, token budgets, or evaluation harnesses, and a sense of what agents need from the systems beneath them.
- Experience designing data models for messy, interconnected domains. You know how to structure data so it stays correct as it grows and changes, and you think about how it will be queried and served before you write the schema. You've made schema and storage decisions that held up under scale, and you know the cost of getting them wrong.
- You keep work moving. You balance speed of execution with code quality, unblock yourself when you can, and pull in the right people at the right time when you can't.
Bonus Points- Hands-on with vector databases (pgvector, Pinecone, Turbopuffer) or hybrid search systems
- Experience with Kotlin/JVM (our primary stack) or Rust, MongoDB, Postgres, or Redis, and WebSockets or other real-time patterns
- You've built sandboxing or isolation systems with containers or microVMs (e.g., Firecracker, gVisor), or managed fleets across heterogeneous machines
- You've worked on filesystem layers such as FUSE, overlay filesystems, or remote-backed storage
- You've worked with event sourcing, lineage, or provenance data, where the record of what happened is itself a product
What success Looks like In your first month, you've shipped to production, learned how work moves through the platform end to end, and taken ownership of a real component in one of the layers above.
By three months, you own a meaningful piece of the system and have made it measurably better: longer-running work that survives failures, faster sandbox startup, context that reaches agents more reliably, or fewer dropped handoffs between agents and people.
By six months to a year, you're the person the team trusts with a layer of the machine. You set its technical direction, anticipate where it will break as customers and workloads grow, and your work shows up directly in how much our agents can take on.
