Systems Engineer

Dedalus Labs; San Francisco (CA); On-site; USD 150,000 - 210,000; Full time

Benefits offered by this job

Relocation support

Visa sponsorship

Equity

Job summary

Dedalus Labs in San Francisco is hiring systems engineers to build the compute substrate for an agent-native economy. You will work on core primitives, virtualization, isolation, and storage for long-running AI agents, delivering low-latency and reliable infrastructure.

You will own end-to-end development in a fast-paced, collaborative environment. Relocation support and visa sponsorship are offered, with a competitive salary, bonus, and meaningful equity.

Qualifications

• Experience building substantial systems software in Rust, Go, C, or C++ or similar languages.
• Strong software engineering fundamentals including data structures, concurrency, memory, and performance.

Responsibilities

• Develop core compute and runtime primitives for long-running AI agents.
• Contribute to virtualization, sandboxing, and isolation for multi-tenant workloads.
• Build low-latency scheduling and resource-management systems.
• Create profiling, debugging, and performance tooling for production systems.

Skills

Rust/Go/C/C++

CS fundamentals

OS/Distributed systems

Owner mindset

Debugging systems

Performance tuning

Tools

KVM

Firecracker

Job description

Mission

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.

You might thrive here if you

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

What you’ll build

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

Representative projects

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.

What we look for

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

Nice-to-have

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

Taste

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.

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.