Systems Engineer Intern

Dedalus Labs is an AI research neolab building infrastructure for AI agents.

We’re building the persistent compute layer that powers the next generation of autonomous software. Our platform spans distributed storage, virtualization, orchestration, networking, scheduling, and runtime infrastructure for long-running AI agents.

We’re looking for unusually high-potential engineers who want to learn how reliable systems are designed, built, broken, and improved.

About the internship

This is a paid, full-time, approximately three-month internship based in San Francisco.

Applications remain open on a rolling, year-round basis. When we meet an exceptional or unusually high-slope engineer, we can invite them to join the team for a season.

You’ll work directly alongside Dedalus engineers on real infrastructure, not a disconnected intern project. You may shadow experienced engineers, but you’ll also be expected to take ownership, write production-quality code, investigate difficult problems, and explain your decisions.

Interns who demonstrate exceptional technical ability, judgment, ownership, and mutual fit may be considered for full-time roles.

• Think abstractions are useful because you understand what’s underneath them.

• Enjoy figuring out how operating systems, networks, and distributed systems actually work.

• Care about latency, throughput, memory usage, and system reliability.

• Like debugging difficult problems and learning from them.

• Think distributed systems are fun rather than frightening.

• Read systems blogs or papers because you’re genuinely interested.

• Build things outside of class simply because you enjoy it.

• Believe the best infrastructure disappears into the background.

• Are high agency and fiercely independent.

• Say how things ought to be built, then build them.

• Are a competitive teammate with a heart of gold.

• Are hungry to learn, improve, and reflect deeply on feedback.

• Go above and beyond in everything you do.

• 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-grade systems software in Rust, Go, C, or C++.

You might find yourself working on problems like:

• Reducing sandbox startup latency from seconds to milliseconds.

• Building snapshot and recovery mechanisms for persistent agent state.

• Designing a scheduler for thousands of concurrent, long-running workloads.

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

• Improving isolation and resource controls for secure multi-tenant execution.

• Building test harnesses that simulate machine loss, degraded networks, and partial failures.

• Implementing or evaluating ideas from systems research against our production architecture.

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

• Experience building and debugging software in Rust, Go, C, C++, or another systems-oriented language. Rust is preferred but not required.

• Exposure to systems through coursework, research, open source, internships, or self-directed projects.

• Curiosity about how operating systems, networks, storage, and runtimes work beneath their abstractions.

• The ability to investigate difficult bugs, reason clearly about tradeoffs, and communicate what you learn.

• High agency, fast learning, thoughtful responses to feedback, and end-to-end ownership.

• A storage engine, scheduler, database, runtime, compiler, operating system, hypervisor, container system, or distributed service you built.

• Experience with virtualization, sandboxing, containers, or hypervisors.

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

• Experience profiling or optimizing latency, throughput, memory usage, or resource consumption.

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

• A project where you encountered a difficult failure and can explain how you diagnosed it.

You know the difference between code that merely works and code that’s built to last.

You care about elegant engineering, good abstractions, and understanding why systems behave the way they do.

The first thing we look at is your GitHub.

Show us things you’ve built. Personal projects. Research. Hackathons. Operating systems projects. Infrastructure tooling. Homelabs. Open-source contributions.

We care far more about demonstrated curiosity and technical ability than your class year or prior internship experience.