INFRASTRUCTURE ENGINEER INTERN @ DEDALUS LABS
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 distributed systems are one of computer science's most beautiful subjects.
- Want to understand why systems fail—not merely how to make the happy path work.
- Have built something technically difficult relative to your experience.
- Can explain the hardest part of a project, what failed, and what you personally contributed.
- Care about consistency, fault tolerance, concurrency, latency, and system correctness.
- Enjoy learning how operating systems, storage engines, schedulers, networks, and runtimes work.
- Read technical papers, source code, or engineering postmortems because you are genuinely curious.
- Prefer building and experimenting over collecting credentials.
- Learn unusually quickly and act deeply on feedback.
- Are comfortable working through ambiguity and taking ownership without waiting for detailed instructions.
- Believe simple systems are often harder to build than complicated ones.
- Measure before optimizing, then optimize relentlessly.
- Are high agency and fiercely independent.
- Are a competitive teammate with a heart of gold.
- Go above and beyond in everything you do.
WHAT YOU'LL WORK ON
Depending on your strengths and the company's needs, you may contribute to:
- Distributed infrastructure for large-scale AI agent workloads.
- Persistent compute and distributed storage systems.
- Scheduling and orchestration platforms.
- Virtualization, containerization, and sandboxing infrastructure.
- Reliable multi-tenant cloud systems.
- Internal developer platforms and infrastructure tooling.
- Performance, reliability, observability, and failure recovery.
- Production systems operating under real-world latency and fault-tolerance constraints.
REPRESENTATIVE PROJECTS
You might find yourself working on problems like:
- Building a component of a distributed storage system for persistent agent state.
- Improving the reliability or recovery behavior of a production service.
- Designing scheduling infrastructure for concurrent, long-running agent workloads.
- Investigating a bottleneck across storage, networking, scheduling, or runtime layers.
- Building internal tooling that makes infrastructure easier to operate and debug.
- Designing tests that simulate partial failures, machine loss, or degraded networks.
- Improving observability for distributed workloads.
- Prototyping a new isolation, caching, or orchestration mechanism.
- Reading a systems paper, implementing part of it, and comparing its tradeoffs with our architecture.
Your project will be scoped to the internship, but it should matter to the company and be used by real engineers or systems.
WHAT WE LOOK FOR
- A public GitHub profile is required.
- Demonstrated programming ability in Rust, Go, C, C++, or a similar language.
- Evidence that you have built and completed technically meaningful projects.
- Solid computer-science fundamentals and a genuine interest in systems.
- The ability to reason clearly about tradeoffs, failure modes, and debugging.
- Specificity about what you personally built and why you made particular decisions.
- High agency, intellectual honesty, curiosity, and learning velocity.
- Strong written and verbal technical communication.
- The ability to work full-time and in person from our San Francisco office for approximately three months.
- A specific reason you want to work on infrastructure for AI agents at Dedalus.
We evaluate candidates relative to their experience and opportunities. You do not need a prestigious employer, advanced degree, or long résumé. Students, recent graduates, researchers, self-taught engineers, open-source contributors, and early-career engineers are all welcome to apply. What matters is the difficulty and quality of what you have done, what you personally owned, and how quickly you are improving.
ESPECIALLY STRONG SIGNALS
- Self-directed systems projects built beyond required coursework.
- Meaningful open-source contributions.
- A storage engine, scheduler, database, runtime, compiler, operating system, hypervisor, container system, or distributed service you built.
- A correct implementation of Raft, Paxos, replication, sharding, or another distributed-systems concept—with thoughtful testing and documentation.
- Technical writing that explains architecture, failure modes, and tradeoffs.
- Evidence that other people use or depend on something you built.
- Research accompanied by a working implementation.
- A project where you encountered a difficult failure and can explain how you diagnosed it.
- Repeated evidence of unusually fast learning and end-to-end ownership.
Class projects can demonstrate baseline knowledge. Projects that you initiated, substantially extended, or pursued beyond their requirements are generally stronger signals.
NICE TO HAVE
- Experience with distributed storage systems.
- Familiarity with consistency models, consensus algorithms, or replication protocols.
- Experience with Kubernetes or modern cloud infrastructure.
- Experience with virtualization, hypervisors, containers, or Firecracker.
- Kernel, operating-systems, or low-level runtime experience.
- Experience with concurrency, networking, or performance engineering.
- Contributions to systems-focused open-source projects.
- Published or ongoing systems research.
- Experience operating infrastructure used by real users.
- Familiarity with infrastructure for AI agents or long-running workloads.
These are advantages, not a checklist. We care more about demonstrated potential and ownership than whether you satisfy every item.
TASTE
You are beginning to understand the difference between a distributed system that works and one that continues working when everything goes wrong. You care about simple architecture, principled tradeoffs, clear abstractions, and infrastructure that other engineers can trust. You are not expected to know everything. You are expected to learn quickly, think deeply, and care about getting the details right.
WHAT SUCCESS LOOKS LIKE
By the end of the internship, we hope you will have:
- Owned and shipped a meaningful infrastructure project.
- Developed a deeper understanding of production distributed systems.
- Demonstrated strong technical judgment and debugging ability.
- Responded thoughtfully and quickly to feedback.
- Written clear code, tests, documentation, and architectural reasoning.
- Made Dedalus's infrastructure meaningfully more reliable, performant, or usable.
- Given the team enough evidence to assess possible long-term fit.
LOGISTICS
- Rolling applications throughout the year.
- Approximately three months, with exact dates agreed upon individually.
- Paid, full-time internship.
- Five days per week in person in San Francisco.
- Meals and office benefits included.
- Relocation support may be available.
- Visa support may be considered depending on the candidate and circumstances.
- Possible consideration for full-time employment, without any guarantee of conversion.
TIPS
The first thing we look at is your GitHub. Show us the best systems work you have built: infrastructure, research implementations, storage engines, schedulers, distributed services, runtimes, operating-systems projects, open-source contributions, or technically ambitious experiments. For your strongest project, tell us:
- What you personally built.
- Why it was difficult.
- The hardest bug or failure you encountered.
- The architectural tradeoffs you made.
- What you would do differently now.
- Where we can inspect the code, documentation, or result.
A smaller project you deeply understand is more compelling than a popular project where your contribution is unclear. We care far more about what you have built, how well you understand it, and how quickly you are improving than the number of years on your résumé.