You SSH into a box you haven't touched in three months. What runtime is on it? Which services matter? Where does nginx log? You re-discover all of it, every time — and so does every teammate, and so does every AI agent you point at it.

Servonaut's server memory fixes the re-discovery tax. The CLI builds a compact, structured snapshot of each server — OS, runtimes, services, web stack, databases, containers, logs, network, git checkouts, disk — and syncs it so the knowledge is there the next time you (or your agent) open that box, from any machine.

And like everything else we sync, the server never sees the plaintext.

Memory that follows the server, not the laptop

Each snapshot is split into modules and encrypted client-side with AES-256-GCM before it leaves your machine. The backend stores opaque ciphertext — it can route it, dedup it, and hand it back, but it cannot read it. Switch laptops, rebuild your workstation, hand a box to a colleague: the memory is keyed to the server, so it travels with the server, not with the machine that happened to probe it first.

That's the part that makes an MCP-connected agent genuinely useful. When you tell Claude Code "check the web stack on prod-web-2", it doesn't start from zero — it starts from what's already known about that box, and spends its budget on the actual question.

Agents that learn each box

The new piece: agents can now write memory, not just read it.

Two authored module types ride the same encrypted sync:

  • Annotations — notes you attach to a server by hand. "This box runs the nightly billing job — don't reboot before 3am."
  • Findings — notes an agent persists during a session. It figures out that a service is misconfigured, or that a log path moved, or that a dependency is pinned for a reason — and it writes that down, encrypted, for next time.

The next agent that opens the box inherits those findings. Knowledge compounds across sessions instead of evaporating when the context window closes.

Because authored notes are written, not probed, we treat them differently from system state: a probe that shows disk jumping from 40% to 85% is drift worth surfacing; an edit to a note is just an edit. So annotations and findings are exempt from drift and anomaly detection — no false alarms from your own notes.

Shareable across a team — same zero-knowledge guarantee

On Teams, memory is shareable per server through grants, and findings ride that same path. Grant a teammate access to a box and they get its memory — all modules, or a scoped subset like findings only. The sharing is done with per-recipient key wrapping: the server brokers who-can-read-what without ever holding a key that decrypts the content.

So an agent's hard-won understanding of a server becomes team knowledge — without anyone, including us, being able to read it off the wire.

The shape of it

  • End-to-end encrypted. AES-256-GCM, keys derived from a passphrase you control. The backend stores ciphertext and never decrypts.
  • Keyed to the server. Memory travels with the box across all your machines.
  • Readable and writable by agents. Over the hosted MCP server, agents start informed and leave the box smarter than they found it.
  • Team-shareable, per server, per module. Existing grants, same zero-knowledge guarantee.

Your servers already have a memory — it's just been trapped in your head, and lost every time you close the terminal. Now it travels with the box, and the agents that work on it can finally remember what they learned.

Get started with the installation docs.