Dedalus Labs – Persistent Linux VMs for AI Agents in 250ms

TL;DR

TL;DR: Dedalus Labs runs persistent Linux VMs that boot in under 250ms with full VM isolation, letting you deploy AI agents without managing Dockerfiles or YAML configs.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: dedaluslabs.ai ← visited and verified
• Documentation: docs.dedaluslabs.ai ← visited and verified
• SDK source: github.com/dedalus-labs/dedalus-sdk-python ← read README
• HN launch thread: news.ycombinator.com/item?id=45054040
• YC page: ycombinator.com/companies/dedalus-labs
• License (SDK): MIT (verified via GitHub README)

What Is Dedalus Labs?

Dedalus Labs describes itself as “Vercel for Agents” — a cloud platform for developers to build and deploy agentic AI applications. The core primitive is a Dedalus Machine: a persistent Linux VM that boots in under 250ms, with full root access and VM-level isolation.

Key claims from their marketing (verified on dedaluslabs.ai):

• Boot time: under 250ms for a full Linux machine
• Persistence: VMs never sleep — you pay only for active compute; sleep is free
• Isolation: VM-level isolation per agent
• SDK: Connect any LLM to any MCP tool (Model Context Protocol), local or hosted
• No YAML/Dockerfile required — agents run on production infrastructure out of the box
• YC backing: Y Combinator W25 (actually S25 based on their HN post and YC company page)

The platform sits between a raw cloud VM and a managed agent framework. You get full Linux with ssh access, but the lifecycle is managed for you — the agent runtime is pre-wired to your MCP tools.

Setup Workflow

Step 1: Install the CLI

Dedalus Labs provides a one-line installer for Linux/macOS:

curl -fsSL https://www.dedaluslabs.ai/install/dedalus | bash

This installs the dedalus CLI globally.

Step 2: Create a Machine

After authenticating, create a machine with the CLI. From their homepage example:

dedalus machines create --vcpu 1 --memory-mib 1024 --storage-gib 10

The output shows near-instant provisioning:

dm-01 IDLE up 3m
$ dedalus start
machine created in 12ms
agent ready, listening...

Step 3: Connect Your LLM and MCP Tools

The Python SDK (MIT licensed) is available on PyPI:

pip install dedalus_labs

Basic usage with the Python SDK:

import os
from dedalus_labs import Dedalus

client = Dedalus(
    api_key=os.environ.get("DEDALUS_API_KEY"),
    environment="development",
)

chat_completion = client.chat.completions.create(
    model="openai/gpt-5-nano",
    messages=[
        {
            "role": "system",
            "content": "You are Stephen Dedalus. Respond in morose Joycean malaise.",
        },
        {
            "role": "user",
            "content": "Hello, how are you today?",
        },
    ],
)
print(chat_completion.id)

They also provide an MCP Server so AI assistants like Cursor and VS Code can directly explore the API, make test requests, and pull documentation inline. The MCP server URL is served at https://dedalus-sdk.stlmcp.com.

Step 4: Deploy an Agent

From the HN launch post, the core workflow is:

1. Write your agent logic using the Dedalus SDK
2. Connect it to MCP tools (their cloud or your own self-hosted)
3. dedalus deploy — the machine starts, the agent listens

No container builds, no Kubernetes manifests.

Deeper Analysis

What Makes It Different

The closest comparable is a raw cloud VM (AWS EC2, etc.) but with three key differences:

• Instant boot — 250ms vs. several seconds for a cloud VM. This matters for agent workloads that spin up and tear down frequently.
• Managed lifecycle — you do not SSH in to restart a crashed agent; the Dedalus runtime handles it.
• MCP-native — MCP tools are first-class citizens, not afterthought integrations.

vs. platforms like LangChain Agents or CrewAI: those are code frameworks running on your infrastructure. Dedalus is the infrastructure itself — you bring the agent logic, they handle the VM, networking, and tool routing.

vs. Vercel/Railway/Render: those host web apps, not long-lived agent processes with persistent state and MCP tool connections.

Pricing

From their pricing page (verified via dedaluslabs.ai):

• Free tier: 50 free hours per month. No credit card required.
• Pro plan: $20/month — higher rate limits, priority support, per-second billing.

The “scale to zero, sleep is free, wake is instant” model means idle agents do not burn budget.

Open Source SDKs

The SDKs are MIT licensed and available on GitHub:

• dedalus-sdk-python — Python client with sync and async support, powered by httpx
• The MCP server is also open source, enabling local-first tool integration

Practical Evaluation Checklist

• Boot speed: under 250ms (verified from dedaluslabs.ai)
• Pricing model: free tier + $20/month (verified from dedaluslabs.ai)
• SDK available: Python SDK on PyPI (verified from GitHub README)
• MCP support: yes, MCP server included (verified from GitHub README)
• License: MIT for SDKs (verified from GitHub README)
• YC backed: yes, YC S25 (verified from YC company page)
• No credit card required for free tier (verified from dedaluslabs.ai)

Security Notes

VM-level isolation is per-machine, not per-agent. If running multiple agents on one machine, consider separate machines per trust boundary. The platform does not yet appear to offer built-in secrets management beyond DEDALUS_API_KEY environment variable — for production workloads, rotate keys regularly and use their BYOK model for model providers if available.

FAQ

Q: How does Dedalus differ from just using AWS EC2? A: No manual provisioning, no AMIs, no SSH key management. The agent lifecycle is managed — boot is 250ms vs. tens of seconds, and MCP tools are wired in without you writing the integration layer.

Q: Can I run my own MCP servers on Dedalus Machines? A: Yes. The HN launch post mentions connecting to “any MCP tools — local or hosted by us.” You have full Linux root access.

Q: Does it work with non-OpenAI models? A: Yes. The SDK is model-agnostic and the example shows openai/gpt-5-nano but the API is OpenAI-compatible, so any model with an OpenAI-compatible endpoint works.

Q: What happens when a machine sleeps? A: Sleep is free and the machine wakes instantly when a request comes in. You only pay for active compute minutes.

Q: Is the source code open source? A: The SDKs (Python, and presumably others) are MIT licensed on GitHub. The core cloud platform is not open source.

Conclusion

Dedalus Labs targets a specific gap in the agent infrastructure space: you want the control of a Linux VM but the developer experience of a managed platform. The 250ms boot time and MCP-native routing are the differentiating features — not just for toy demos but for production agents that need persistent memory and reliable tool access.

The free tier (50 hours/month, no credit card) is enough to evaluate the workflow. If you are building agents that currently live in a LangChain abstraction over a cloud VM, Dedalus Machines are worth a serious look.

Next steps:

• Install the CLI: curl -fsSL https://www.dedaluslabs.ai/install/dedalus | bash
• Read the docs: docs.dedaluslabs.ai
• Check the Python SDK: github.com/dedalus-labs/dedalus-sdk-python