Systems Engineer Intern

Dedalus Labs, Inc.; San Francisco (CA); On-site; USD 45,000 - 58,000; Full time

Benefits offered by this job

Paid internship

Potential full-time role

Based in San Francisco

Job summary

Dedalus Labs, Inc. in San Francisco offers a paid, full-time internship of about three months. You will work directly alongside Dedalus engineers on real infrastructure, take ownership, write production-quality code, and investigate difficult problems.

Outstanding engineers who ship decisions with sound tradeoffs and learn quickly will be considered for full-time roles. This is a chance to impact long-running AI agent systems and learn OS, networking, and distributed systems fundamentals.

Qualifications

• Paid, full-time internship for about three months in San Francisco.
• Work on real infrastructure with ownership and production-quality code.
• Shadow engineers but also take ownership and explain decisions.

Responsibilities

• Shadow experienced engineers while contributing to real infrastructure.
• Take ownership of tasks and deliver production-quality code.
• Investigate difficult problems and communicate decisions clearly.
• Prepare for potential full-time roles based on performance.

Skills

Programming fundamentals

Concurrency

Performance

Tools

Rust

Go

C

C++

Job description

Mission

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.

You might be a fit if you

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

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

Representative projects

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.

What we look for

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

Especially strong signals

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

Taste

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.

Tips

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.