We make the compute you've already paid for do more.

This seat owns how we ship — build, delivery and quality — and, just as much, hiring and growing the team that does it.

What you'll own

• Engineering delivery end to end: roadmap, quality, release.
• Hiring and leading the founding engineers, and the standard for correctness and measurement.
• Being the technical peer who can push back on anyone — founders included.

What we're looking for

• Principal-level in compilers or systems, with both shipping and management behind you.
• A player-coach who still reads the code.
• You've shipped systems that ran in real production, not just prototypes — and built the small, senior, high-trust teams that did it.

Apply →

A senior individual-contributor seat for someone who wants to shape the hardest parts of the system, hands-on, and pull the technical bar up around them.

What you'll own

• Technical direction on the deepest systems and performance problems, across CPU and accelerators.
• The experiments that de-risk our hardest bets and turn them into shipped, production-grade capability.
• The bar for how we measure and reason about performance.

What we're looking for

• A recognized systems or performance engineer — deep in compilers, kernels, or accelerator systems.
• You've made real production systems faster and can prove it — at scale, not on a bench.
• Deep enough to set direction; the kind of engineer other strong engineers want to work with.

Bonus points for

• Cross-domain range — you've gone deep in more than one of compilers, runtime, GPU/accelerators, or distributed systems.
• Experience operating what you build in large production environments.
• Rust — you'll be working in and around a framework we've already built in it.

Apply →

The core of the product finds a better-compiled version of a function for the hardware in front of us — and does it while the program runs. You own that engine: the compiler, the runtime, and the tooling that keeps it fast and correct.

What you'll own

• The compiler and runtime pipeline end to end, from IR to native code that ships into live systems.
• Correct, reproducible code generation across targets (x86, ARM, RISC-V).
• Deep LLVM work — passes, codegen, and the tooling around them — proven on real workloads, not microbenchmarks.

What we're looking for

• Real depth in compilers and LLVM / LLVM IR.
• Strong C/C++; at home in the guts of optimization passes and codegen.
• A bias for measurement — you prove a pass helps on production code, you don't assume it.
• You've shipped compiler or runtime work that ran in production, not just in a paper.

Bonus points for

• MLIR, and familiarity with ML-compiler stacks (XLA, TVM, Triton).
• Runtime internals: dispatching work to kernels, launch APIs, memory allocators, JIT.
• Comfortable profiling and debugging hot, performance-sensitive code at scale.
• Rust — you'll be working in and around a framework we've already built in it.
• FORTRAN (the math still lives there); experience shipping a toolchain others depend on.

Apply →

We drive software with live signals from the hardware — and it has to hold up across large production fleets, not one box on a bench. You build the layer that reads those signals, acts on them safely, and keeps them reliable at scale.

What you'll own

• Low-overhead performance instrumentation from hardware, running in production.
• Scheduling and placement of work across a mix of processors and many machines.
• Correctness, safety and reliability of changes made to live, multi-node systems — rollout, observability, recovery.

What we're looking for

• Depth in performance engineering and systems.
• Hands-on with perf tooling (perf, VTune, PMCs) and OS internals / schedulers.
• You've operated multi-node systems in production at fleet scale — not just benchmarked one.
• You've made real systems measurably faster and kept them reliable.

Bonus points for

• Distributed-systems depth: concurrency, fault tolerance, RPC, control planes.
• Real experience with cluster schedulers and Kubernetes (beyond basic use); provisioning, quotas, observability.
• High-speed networking (RDMA), drivers/firmware, or HPC.
• Linux / FreeBSD kernel work, tracing, or production reliability (SRE) at scale.
• Go, C++ or Python for systems work.

Apply →

A modern box has more than a CPU, and the interesting work is making the system use the right silicon well — live, across a range of accelerators, not one vendor's stack.

What you'll own

• Accelerator kernels across multiple targets — broad, not single-vendor.
• Getting real work onto GPUs and FPGAs and making it fast in production.
• The accelerator side of the runtime, close to the metal.

What we're looking for

• Real depth in GPU programming and/or FPGA / HDL.
• Comfortable at the level of kernels, machine code, and what the hardware is actually doing.
• Multi-target instincts: you think in capabilities, not one vendor's SDK.
• You've shipped accelerator work that ran in production, not just demos.

Bonus points for

• Fluency with accelerator programming models (ROCm, CUDA, Triton, CUTLASS) and how GPUs actually execute — warps and wavefronts, thread blocks, grids.
• Memory and throughput tuning — coalesced access, shared-memory and cache use, occupancy, latency hiding, ILP.
• Nsight (or equivalent) profiling; experience spanning several GPUs and distributed execution.
• FPGA: HLS or Verilog; tensor-core or systolic-array experience. We'd love one GPU-leaning and one FPGA-leaning hire.

Apply →

Efficiency only matters if it shows up on real serving traffic. You connect low-level systems work to end-to-end inference results on production serving stacks.

What you'll own

• Understanding how real inference workloads behave on modern serving stacks, at scale.
• The experiments that turn systems-level work into a reproducible end-to-end result.
• The work that makes our design-partner pilots succeed in production.

What we're looking for

• Depth in ML systems / inference performance.
• Hands-on with modern serving frameworks and GPU inference in production.
• You can connect a low-level change to an end-to-end serving result — and you've done it on live traffic.

Bonus points for

• Inference runtimes: vLLM, SGLang, TensorRT-LLM, or custom serving.
• A working grasp of today's model architectures and how attention is implemented.
• Serving internals — how requests get batched, scheduled and run concurrently, and how the KV cache is managed and laid out in memory.
• Quantization; tuning systems where latency and throughput both matter; benchmarking at scale.
• Python and C++.

Apply →

Pilots succeed or fail on the ground, inside someone else's production. You embed, integrate, and make the result real and reproducible on their fleet.

What you'll own

• Embedding with the teams that run large compute fleets to stand up and run pilots.
• Turning a research system into a deployment that survives someone else's production.
• The feedback loop from the field back into the product.

What we're looking for

• Spanning systems engineering and customer-facing delivery.
• Credible with senior infra engineers; calm in someone else's production.
• You've stood things up in large production environments — and you like shipping a result more than owning a codebase.

Bonus points for

• Performance / observability background; prior FDE, FAE, or solutions-engineering at an infrastructure company.
• Comfortable operating a fleet: Linux, Kubernetes, networking, incident response.

Apply →

A small team moving fast needs one person who makes everything else run.

What you'll own

• Operating cadence, fundraising support, partner and investor logistics.
• The connective tissue across engineering, partners and the founders.
• Whatever is most important and least owned that week.

What we're looking for

• A high-ownership operating, strategy, or founder-adjacent background.
• Comfortable with ambiguity and direct with principals.

Bonus points for

• Prior zero-to-one startup experience; technical literacy.

Apply →