Move Your AI Agent Off Your Laptop

A recent poll on Product Hunt asked developers how many AI agent instances they run in parallel. Over half said one or two.

And yet, the most common complaint is: my laptop can't keep up.

It's not really the agent's fault. Your machine was already struggling before the agent launched. Cursor or VS Code eating 2-4GB. Docker Desktop sitting at 4GB whether you're using it or not. Chrome with 40 tabs. Slack. Figma. Your laptop is already at 80% capacity just from your normal workflow.

Then your AI agent kicks off a build, runs a test suite, starts pulling npm packages. That's the moment the macOS force quit window shows up.

Your laptop is already full

The agent isn't the problem. The agent is the last thing that doesn't fit. Your machine is a place for thinking, browsing, writing code, joining calls. It was never meant to also be a build server.

And there's the fragility issue. You close your laptop to grab lunch and your agent's 20-minute refactoring session dies. You leave a long task running overnight and macOS puts your machine to sleep at 2am.

The fix isn't a faster laptop. It's getting the heavy work off your laptop entirely.

The manual way: VPS + tmux + Tailscale

The developer community has already figured this out. There's a whole genre of blog posts and tutorials about running AI agents on a VPS. The typical setup looks like this:

1. Rent a server on Hetzner or DigitalOcean ($5-10/month)
2. Create a non-root user and configure SSH keys
3. Install Node.js via nvm
4. Install your agent (Claude Code, aider, codex) via npm/pip
5. Set up tmux for session persistence
6. Install Tailscale for private networking
7. Configure your firewall (UFW + Fail2Ban)
8. Set up a mobile terminal app (Termius or Blink) for access from your phone

The blog posts call this "one afternoon of setup." That's optimistic. And you have to do it again for every project, or manage a single server that accumulates the same state pollution you were trying to escape from your laptop.

The server also runs 24/7 whether you're using it or not. Forget to shut it down and you're paying for an idle machine indefinitely.

The one-command way

gibil create --name my-task --repo github.com/you/project

That's it. In about 60 seconds you have a fresh Ubuntu server on Hetzner with root access, Docker, Node.js, and your repo already cloned. SSH keys are generated automatically. No tmux setup, no firewall config, no Tailscale.

Run your agent's work on it:

gibil run my-task "cd /root/project && pnpm install && pnpm test"

Or SSH in directly if you want to poke around:

gibil ssh my-task

When you're done, burn it:

gibil destroy my-task

The server is gone. No orphaned VPS billing you next month. No state to clean up.

Why this matters even for one agent

You don't need five agents in parallel to benefit from remote compute. Here's what changes with even a single agent on a remote server:

Your laptop stays usable. Your agent can run a heavy build or a full test suite without your fan screaming or your browser stuttering. You keep working on something else while the agent does its thing.

Long tasks survive. Set a TTL and the server stays alive regardless of what your laptop does. Kick off a task, close your laptop, and SSH back in later to check the results.

gibil create --name long-task --repo github.com/you/project --ttl 120
gibil ssh long-task
# on the server: nohup bash -c "cd /root/project && pnpm install && pnpm build && pnpm test" &
# close your laptop, the server keeps running

Every run starts clean. No cached dependencies lying to you. No stale environment variables from three projects ago. No "works on my machine" surprises. If the test passes on a fresh server, it passes in CI.

The agent can't break your local environment. AI agents are powerful and sometimes unpredictable. On your laptop, a bad rm -rf or a broken npm install costs you an hour of recovery. On a throwaway server, you destroy it and forge a new one in 60 seconds.

For MCP-compatible agents

If you're using an MCP-compatible agent, gibil works as an MCP server. Add it to your agent's config and it can forge and destroy its own servers without you running commands manually.

{
  "mcpServers": {
    "gibil": {
      "command": "gibil",
      "args": ["mcp"]
    }
  }
}

Your agent gets access to tools like create_server, vm_bash, vm_read, vm_write, and destroy_server. It can spin up a machine, run whatever it needs, and clean up when it's done. You don't even need to be in the loop.

The cost

A default gibil server (Hetzner cax11) costs about $0.03 per hour. A 30-minute test run costs less than two cents. You bring your own Hetzner account and pay Hetzner directly. Gibil itself is free during alpha.

Compare that to a $10/month VPS running 24/7 that you use for maybe 2 hours a day. The math is obvious once you're only paying for time you actually use.

What's still rough

Gibil is early. Boot time is about 60 seconds, which is fast enough for real work but slow if you're used to instant local commands. We're working on VM snapshots to get that under 15 seconds.

Only Hetzner is supported right now. The provider interface is ready for Fly.io and AWS, but those adapters haven't been built yet.

There's no web dashboard. Everything is CLI. For most developers that's fine. For teams, we'll probably need one eventually.

Getting started

npm install -g gibil
gibil init  # configure your Hetzner token
gibil create --name try-it --ttl 15
gibil ssh try-it
gibil destroy try-it

The whole flow takes about two minutes from install to SSH-ing into a fresh server. No account needed, no credit card for gibil. You just need a Hetzner API token.

Docs: gibil.dev/docs