If you want a persistent Linux VM in the cloud that you reach over SSH and share over HTTPS, exe.dev and Jilebi are solving a very similar problem. Both give you real VMs (not ephemeral containers), persistent disks, and SSH-first workflows. The differences are in pricing model, sizing flexibility, and where each product is headed.
This post compares Jilebi Machines with exe.dev across price, performance, ease of use, and technology, and ends with an honest pros-and-cons list.
TL;DR
| Dimension | Jilebi | exe.dev |
|---|---|---|
| Price model | Pure usage-based: ~$0.009/vCPU-hr + ~$0.009/GB-hr RAM, disk-only when paused | Flat monthly pool: from $20/mo (2 vCPU / 8 GB shared across all VMs) |
| Best for cost | Bursty / part-time use, many machines that sleep | Always-on use inside your pool, many small VMs sharing capacity |
| Performance | Bare-metal microVMs, ~50ms boot, auto-sleep/wake; dedicated sizing per machine (1–16 vCPU), NVMe | KVM VMs sharing your pool’s CPU/RAM, fast copy-on-write clones (~0.4s) |
| Ease of use | Web console, SSH via proxy, per-port HTTPS exposure on *.jilebi.dev | Legendary SSH UX: ssh exe.dev ... manages everything, no dashboard needed |
| Technology | Cloud Hypervisor microVMs, btrfs snapshots, pause/resume, no public IP by default | KVM VMs, pooled resources, persistent disks, private-by-default with one-command sharing |
Prices below are from public pricing pages at the time of writing (September 2026) and can change — check both sites before deciding.
Price
exe.dev sells you a pool of resources for a flat monthly fee. The Small tier is $20/mo (individual) for 2 vCPU / 8 GB RAM shared across up to 50 VMs, with 100 GB pooled disk. Larger pools scale linearly: 4 vCPU / 16 GB at $40/mo, 8 vCPU / 32 GB at $80/mo, 16 vCPU / 64 GB at $160/mo. Team plans are $25/user/mo for the same pool size per user. Overages apply for extra disk (~$0.08/GB/mo) and transfer. There is also usage-based pricing (about $0.05/core-hr CPU, $0.016/GiB-hr active memory) for spiky needs.
Jilebi is pure pay-for-what-runs: about $0.009 per vCPU-hour and $0.009 per GB-hour of RAM. A paused machine bills disk only (nominal per-GB-hour). There is no monthly base fee and no pool to size in advance.
Worked example — one 4 vCPU / 8 GB machine:
- Jilebi running: (4 × $0.009) + (8 × $0.009) ≈ $0.108/hr. Run it 8 hours a day for 30 days ≈ $26/mo. Run it 24/7 ≈ $78/mo. Pause it when idle and you pay disk only.
- exe.dev Small→Medium equivalent: a 4 vCPU / 16 GB pool is $40/mo flat, regardless of whether your VMs run 2 hours or 720 hours that month, as long as you stay inside the pool.
So the rule of thumb: if your machines run most of the month inside a fixed pool size, exe.dev’s flat rate wins. If your usage is bursty — agents that work a few hours a day, preview machines per PR, dev boxes that sleep nights and weekends — Jilebi’s per-second usage billing with disk-only pause usually wins, and you never have to pick a tier in advance.
Performance
Both products run real virtual machines with hardware isolation, so noisy-neighbor behavior is far better than shared containers on either side.
- exe.dev VMs share the CPU/RAM of your pool, with burstable capacity across teammates on team plans. Cloning is a standout:
ssh exe.dev cp customer-base customer-1842creates a copy-on-write clone in well under a second. Inactive VMs are detected and CPU billing drops to zero on usage pricing. - Jilebi machines get dedicated sizing per machine (any mix of 1–16 vCPUs, 1–16 GB RAM, 30–65 GB NVMe) on bare-metal hosts — no nested virtualization, no noisy cloud neighbors. New machines boot in ~50ms, idle machines auto-sleep and wake on use, and disks are persistent NVMe with btrfs snapshots, so an idle agent box resumes with its state intact instead of cold-booting.
For long compiles (Rust, Haskell, Nix builds — the workload Jilebi was built for), dedicated vCPUs on bare metal with local NVMe is the configuration that matters most, and it is Jilebi’s default. For running dozens of small, mostly-idle VMs inside a fixed budget, exe.dev’s pooling is the more efficient design.
Ease of use
exe.dev has one of the best CLIs in the category: everything happens through ssh exe.dev — create, resize, clone, share, add domains, manage teams. No dashboard to learn, fully scriptable, and every VM gets HTTPS and SSH with sensible secure defaults. Custom domains with automatic TLS are a one-liner.
Jilebi is console-first: sign up at jilebi.ai, pick CPU/RAM/disk per machine, set your SSH keys, and install from a software catalog (nix, opencode, claude code, codex, docker) at creation time. Machines have no public IP by default; you SSH in through the proxy and expose individual ports to *.jilebi.dev with TLS when you want them public. Per-machine sizing (rather than pool sizing) means no capacity planning: every machine is exactly the shape you asked for.
If you live in the terminal and want infrastructure-as-SSH-commands, exe.dev’s UX is hard to beat. If you want a visual console, per-machine sizing, and a pre-baked AI-agent software catalog, Jilebi is the shorter path.
Technology
| Aspect | Jilebi | exe.dev |
|---|---|---|
| Virtualization | Cloud Hypervisor microVMs on bare metal | KVM VMs |
| Storage | Persistent NVMe, btrfs, snapshots | Persistent disks, pooled quota, copy-on-write clones |
| Lifecycle | Auto-sleep / wake / snapshot per machine | Start / stop / clone / resize inside pool capacity |
| Networking | No public IP by default; SSH + selective port exposure via proxy, TLS on *.jilebi.dev | Private by default; one-command public sharing, custom domains + automatic TLS |
| OS / images | Ubuntu minimal + software catalog | Full Linux VMs you configure |
| API / automation | Console + proxy; programmability roadmap | SSH-driven CLI, scriptable end to end |
Architecturally both teams made the same core bet — real VMs over containers for isolation — and differ in packaging: exe.dev pools capacity across VMs; Jilebi sizes each machine independently on bare metal.
Pros and cons
Jilebi — pros
- Usage-based billing with disk-only sleep: bursty agent/dev workloads cost a fraction of 24/7 pricing
- ~50ms boot for new machines; idle machines auto-sleep and wake on use
- Dedicated per-machine sizing (1–16 vCPU / 1–16 GB) on bare-metal hosts with local NVMe
- Snapshot / pause / resume per machine; state survives idle periods
- Private by default (no public IP); selective HTTPS exposure with TLS
- Software catalog for AI tooling (nix, opencode, claude code, codex, docker) at creation time
Jilebi — cons
- pay-per-hour running costs exceed a flat pool if you run large machines 24/7 all month
- No built-in pooled/burstable capacity across machines yet
- Younger product: smaller docs corpus and community than exe.dev
- GPU machines not offered today
exe.dev — pros
- Flat-rate pools: predictable bill, unlimited VM count inside capacity (up to 50)
- Exceptional SSH-native UX; everything scriptable in one-liners
- Sub-second copy-on-write clones; great for per-customer / per-PR VMs
- Custom domains + automatic TLS; internal-vs-external sharing controls
- Mature docs and the “just a computer” mental model
exe.dev — cons
- You must pick (and pay for) a pool tier even in months you barely use it
- VMs share pool CPU/RAM — one hungry compile can squeeze its neighbors
- Disk/transfer overages on top of the subscription
- Less per-machine sizing freedom than Jilebi’s any-mix allocation
Which should you pick?
- Pick exe.dev if you want a predictable flat bill, run many small VMs concurrently inside a known capacity envelope, and love SSH-driven workflows.
- Pick Jilebi if your workloads are bursty (agents, PR previews, personal dev boxes), you want each machine sized exactly, you want disk-only billing when paused, and you want bare-metal microVM performance per machine.
Either way, you get a real VM with a persistent disk and SSH — which is the right primitive for agent work. Try Jilebi at jilebi.ai and compare the bill for your actual usage pattern; that is the comparison that matters.