Systems Engineer

Dedalus Labs is an AI Neolab building the compute substrate for an agent-native economy. Our flagship product, Dedalus Machines, gives AI agents fast, persistent computers where they can run continuously, maintain state, and do production-grade work.

We are building a new compute primitive for long-running autonomous software. Our platform spans virtualization, distributed systems, storage, networking, scheduling, orchestration, and low-level runtime infrastructure. Every millisecond, syscall, and scheduling decision matters.

We are looking for systems engineers who want to understand computers all the way down and build infrastructure that feels simple, fast, and inevitable to the developers using it.

• Think abstractions are most useful when you understand what is underneath them.

• Care about latency, throughput, memory usage, correctness, and tail performance.

• Enjoy debugging problems that take days to understand and minutes to fix.

• Treat reliability and performance as product features.

• Read kernel commits, infrastructure blogs, source code, or systems papers because you are genuinely curious.

• Have informed opinions about operating systems, virtualization, networking, storage, or distributed systems.

• Measure before optimizing, then optimize relentlessly.

• Like turning difficult systems problems into simple developer experiences.

• Work independently, communicate clearly, and take ownership from design through production.

• Are ambitious about the work and generous with your teammates.

• Learn quickly and respond thoughtfully to feedback.
  

• Core compute and runtime primitives for long-running AI agents.

• Virtualization, sandboxing, and isolation systems for secure multi-tenant workloads.

• Persistent state, storage, snapshotting, and recovery mechanisms.

• Low-latency scheduling and resource-management systems.

• Networking and runtime infrastructure across the agent execution path.

• Profiling, debugging, benchmarking, and performance tooling.

• Production systems operating under real-world scale, latency, correctness, and reliability constraints.
  

You might find yourself working on problems like:

• Building a distributed storage layer for persistent agent state.

• Reducing sandbox startup latency from seconds to milliseconds.

• Designing a scheduler that efficiently allocates compute across thousands of concurrent agents.

• Developing virtualization and isolation mechanisms for secure multi-tenant execution.

• Building snapshot, recovery, migration, or resume mechanisms for persistent workloads.

• Profiling bottlenecks across networking, storage, scheduling, and runtime layers.

• Designing test infrastructure that simulates machine loss, degraded networks, resource contention, and partial failures.
  

• Experience building substantial systems software in Rust, Go, C, C++, or a similar language. Rust is preferred but not required.

• Strong software engineering fundamentals, including data structures, concurrency, memory, and performance.

• Depth in one or more of operating systems, distributed systems, networking, storage, virtualization, or runtime infrastructure.

• The ability to reason about performance, reliability, correctness, concurrency, and failure modes.

• Strong debugging skills across systems with many interacting components.

• Evidence of end-to-end ownership in production, open source, research, or technically ambitious independent projects.

• Clear communication and the ability to explain architecture, tradeoffs, and technical decisions.

• High agency, sound engineering judgment, and strong collaborative instincts.
  

• Experience building or operating distributed systems under production workloads.

• Experience with distributed storage, replication, consensus, or consistency models.

• Experience with virtualization, containers, hypervisors, KVM, or Firecracker.

• Kernel, operating systems, networking, or low-level runtime experience.

• Experience building schedulers, storage engines, databases, runtimes, or isolation systems.

• Performance engineering work involving latency, throughput, memory, profiling, or systems optimization.

• Meaningful contributions to systems-focused open-source projects.

• Systems research accompanied by a working implementation.

• Technical writing that clearly explains architecture, failure modes, and engineering tradeoffs.

These are signals, not a checklist. We care more about the depth of what you have built and how well you understand it than whether you match every item.

You know the difference between software that merely works and software that feels inevitable.

You care about elegant abstractions, principled engineering tradeoffs, and building systems that other engineers trust and enjoy using.

• Full-time and in person in San Francisco.

• Relocation support is available.

• We sponsor visas for exceptional talents.

• Competitive salary, bonus, and meaningful equity.

• Meals and office benefits are included.
  

The first thing we look at is your Github.

Show us the systems you have built and the difficult problems you have solved. This could include production infrastructure, open-source contributions, systems research, storage engines, schedulers, runtimes, kernel work, homelabs, performance investigations, or technical writing.

For your strongest project, tell us what you personally owned, what made it difficult, the most interesting failure you encountered, and the tradeoffs you made.

We care far more about the depth of your work than the number of years on your résumé.