Systems Engineer

About the role

Dedalus Labs builds persistent computers for AI agents. Our flagship product, Dedalus Machines, gives agents an isolated environment where they can run software, keep files and state, and work over time.

You'll build the control plane and runtime that create, schedule, isolate, and recover our customers' Machines. The work spans Kubernetes orchestration, distributed resource lifecycles, and our Rust virtual machine monitor (VMM), the software that runs each virtual machine. We welcome depth in the control plane or runtime, with room to work across both.

You'll carry a change from design through implementation, verification, rollout, and operation. The central questions are whether the system remains correct under concurrency and failure, and how efficiently it uses compute, memory, storage, and the network.

What you'll work on

Kubernetes and orchestration. Build and debug controllers and operators, reconciliation loops, scheduling, and workload lifecycles. Reason about desired and observed state, retries, resource cleanup, and recovery after node or network failures. Trace behavior through Kubernetes APIs, networking, storage, and the underlying Linux host.

Control-plane services. Implement the APIs and services that create, schedule, and manage Machines. Design durable state transitions and clear ownership so concurrent requests, cancellation, and partial failures cannot leave resources in an incorrect state.

Rust VMM and runtime. Work on virtualization, guest memory, devices, and Linux I/O. Improve startup, execution, snapshots, and recovery. Understand the boundary between guest, hypervisor, and host, including resource isolation and security.

Performance and correctness. Profile latency, allocations, syscall overhead, networking, and storage on representative workloads. Reproduce races and recovery bugs, use failure injection and property-based tests, and explain what the verification establishes.

Secure interfaces. Build APIs, interprocess communication, and network protocols with explicit trust boundaries. Demonstrate concrete failure or attack paths and verify the fixes.

You'd be a good fit if

• You can explain the concurrency, memory use, state transitions, and failure behavior of systems you have built. You investigate below an API when the cause lies deeper.

• For control-plane work, you bring strong Go or Rust service implementation and practical Kubernetes experience. Controllers, operators, scheduling, networking, and recovery are especially relevant. For VMM/runtime work, you bring hands-on Rust and low-level Linux or virtualization experience.

• You can reproduce a correctness or performance problem, identify the responsible layer, and verify a repair. You understand when unit, integration, end-to-end, and property-based tests provide useful evidence and where their limits lie.

• You can defend a design, engage with objections, simplify it, and finish it. Your code reviews and documentation help another engineer understand the guarantees and remaining limitations.

• You use AI tools thoughtfully and take responsibility for the code, tests, and technical claims you submit.

Additional depth we value

Filesystems, storage engines, databases, distributed systems, and Linux networking can complement either focus. Formal specifications, model checking, or proofs are strong bonuses when you can explain what they established and how they changed the implementation. GPU infrastructure experience is also useful.

Experience at a big tech company or on another large, fast-moving codebase is a plus, not a requirement. We value demonstrated judgment about compatibility, code review, and safe changes across shared components.

These are examples, not a checklist. Show depth in a relevant area and the ability to learn the layers around it. Production, open-source, research, and independent work all count. A particular employer or degree is not required.

Logistics

• 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.

Show us your work

Show us a controller, service, runtime, storage component, or other systems project you built, and a difficult correctness or performance problem you investigated. They can come from the same project. Use existing work.

• Work: Show the code, demo, design, or result. Explain what you personally owned, what you reused, and one decision that made the result better or simpler.

• Investigation: Describe the symptom, your first explanation, the evidence that changed your thinking, and how you established the result. Include the workload or users involved and any important limitations.

• Writing: Share one piece of writing you care about as a separate, required sample. Any medium or length is welcome. Tell us why you wrote it, who it was for, and what you wanted to communicate. Looking back, what works well and what would you change? We care about the quality of your thinking and writing, and your reflection on the work. Link it or paste a redacted excerpt. Explain your contribution and any coauthors or AI assistance.

Work from employment, open source, research, coursework, or independent projects is welcome. Public source code is optional. A redacted excerpt or a concrete account of private work is fine. Keep confidential information out of your application.

Tell us which problem in this role you want to own and why. If your strongest evidence is easy to miss on a resume, point us to it. An existing demo or short screen recording is welcome, and video is optional.