Self-host Ruflo on a 5 € VPS — give your Claude Code agents a home

Ruflo (formerly Claude Flow) is a multi-agent orchestration layer for Claude Code. It ships 100+ specialized agents — coders, reviewers, security auditors, doc writers, architects — and lets them self-organize into swarms, share a vector memory store, and federate across machines.

You can run it locally as a Claude Code plugin and never think about hosting. But the moment you want persistent agent memory across sessions, background workers that keep ticking when your laptop is closed, or federation between teammates' machines, you need a long-running node somewhere on the public internet.

A 5 € Netcup VPS is more than enough.

Why a tiny VPS works for Ruflo

The coordination layer itself is lightweight. The expensive parts (LLM inference) happen at whichever provider you've configured — Anthropic, OpenAI, Gemini, Ollama, etc. Ruflo's job is to route, remember, and coordinate.

What actually lives on your VPS:

• The Ruflo MCP server (Node.js)
• AgentDB — the HNSW-indexed vector memory store
• 12 background workers that auto-trigger for things like audit runs, dependency scans, doc regeneration
• A federation endpoint your other machines can dial into over zero-trust mTLS

A 2 vCore / 8 GB box runs all of this comfortably as long as you give the vector index room to breathe. NVMe storage matters more than CPU here.

1. Provision the box

Sign up for the VPS 1000 G12 (4 vCPU, 8 GB RAM, 256 GB NVMe) using coupon 5799nc17800061380 for one free month. Drop in your SSH public key on creation, and as soon as the box boots, lock it down:

# /etc/ssh/sshd_config.d/00-hardening.conf
PasswordAuthentication no
PermitRootLogin prohibit-password
KbdInteractiveAuthentication no

ufw default deny incoming
ufw default allow outgoing
ufw allow 22/tcp
ufw allow 443/tcp
ufw enable

Reboot, reconnect, confirm sshd came back up cleanly before you close the existing session.

2. Install Ruflo

Ruflo ships as a Node CLI. Install Node 20+ from NodeSource, then:

npm install -g ruflo@latest
ruflo init --wizard

The wizard asks which providers to wire up (Claude, GPT, Gemini, Ollama), where to store memory, and whether to expose an MCP endpoint. Pick MCP server, point storage at /var/lib/ruflo, and let it generate a fresh federation keypair.

If you'd rather treat the whole thing as a service, the official compose file works too:

services:
  ruflo:
    image: ruvnet/ruflo:latest
    restart: unless-stopped
    environment:
      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY}
      RUFLO_FEDERATION_KEY: /run/secrets/fed_key
    volumes:
      - /var/lib/ruflo:/data
    secrets: [fed_key]
  proxy:
    image: caddy:2-alpine
    ports: ["80:80","443:443"]
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
secrets:
  fed_key:
    file: ./federation.key
volumes: { caddy_data: {} }

Caddyfile — terminate HTTPS, forward to the MCP port

mcp.yourdomain.eu {
  encode zstd gzip
  reverse_proxy ruflo:8787
}

Caddy fetches a Let's Encrypt certificate the first time it sees an HTTPS request — no certbot, no cron, no expiry surprises.

3. Wire it up to your Claude Code

On your laptop, register the remote Ruflo as an MCP server:

claude mcp add ruflo --url https://mcp.yourdomain.eu --auth-token "$(cat ~/.ruflo/client.token)"

From this point your local Claude Code sees the full agent catalog and can spawn swarms that run server-side. The neat trick: when you close your laptop, the swarm keeps working on the VPS. When you reopen it, the conversation picks up with full memory of what the agents did while you were away.

4. Federation — letting teammates join the swarm

Each teammate runs their own ruflo client init, sends you their public key, you add it to /var/lib/ruflo/federation/peers/. Ruflo handles the rest: zero-trust mTLS, scoped permissions, audit log per agent action. Two people can now ask the same swarm to refactor the same module without stepping on each other.

5. Backups — the agent memory is the product

Once you've run Ruflo for a few weeks, the AgentDB volume is more valuable than the box itself. Trajectory data, learned patterns, audit logs — none of that is reproducible from scratch. Borg is the right answer:

# /etc/systemd/system/borg-daily.service
[Service]
Type=oneshot
EnvironmentFile=/etc/borg.env
ExecStart=/usr/local/bin/borg-snapshot.sh /var/lib/ruflo

Pair it with a .timer unit that fires nightly at 03:00, push the encrypted archive to a cheap storage box, and you're ransomware-resistant by design.

Common gotchas

• Forgot to run docker compose up -d after reboot — fix it with a tiny systemd unit, not "just remember".
• AgentDB grew past 4 GB and Node started OOM-killing itself — set NODE_OPTIONS=--max-old-space-size=6144 and consider a bigger plan.
• UFW dropped outbound 80 — Caddy's cert renewal silently failed for 60 days, then your domain went dark on a Saturday morning.
• Federation peers using clock-skewed certificates — make sure chrony or systemd-timesyncd is running everywhere.

What to do next

Run the official ruflo doctor after a week — it diagnoses memory bloat, dead workers, and stale federation peers. Pair it with a Prometheus exporter on a sibling VPS and you'll have observability for less than the price of a coffee a month.

If you're going to give a real team access to this swarm, the RS 1000 G12 (dedicated CPU, four cores) ships with two free months on coupon 5159nc17718015444 — that gets you predictable concurrency for the background workers without a meaningful price bump.