About Agent Life

Why we built this

Two situations come up routinely.

The first is the situation that started this project. We had a Mac mini in the corner of the office, an external SSD plugged in over USB, and an agent that had been working on that drive for months — memory, identity, workspace artifacts, credentials for the services it acted in. One day, the drive stopped mounting. We tried the obvious things: different cable, different port, different machine. Nothing. We sent it for recovery and got back a partial pile of files we couldn't reassemble into a working agent, because there was no spec for what a working agent on that runtime actually consisted of. We did what most people in that situation end up doing: we started over.

The second is quieter, and harder to notice while it's happening. ZeroClaw launched while we were running our day-to-day work in OpenClaw. We wanted to try it — the runtime model was different, the performance numbers were compelling, and we like having more than one option in the toolbox. But the agent we used every day had months of accumulated memory in OpenClaw's storage, a tuned persona, and credentials wired into several services. Moving it meant hunting for an export tool that didn't exist, hand-translating identity files between incompatible schemas, re-entering every credential, and accepting that whatever we reconstructed probably wouldn't behave the same. We didn't bother. We kept running OpenClaw, and the runtime we'd been curious about sat in another window unused. That felt wrong — not because OpenClaw was the wrong choice, but because the choice had effectively been frozen.

What both situations share is a single missing piece: an open, neutral format for the durable state of an AI agent, with tooling that backs it up, syncs it, and moves it between runtimes without losing fidelity. That missing piece is what Agent Life is.

Agent memory is appreciating infrastructure. The longer an agent has been working with you, the more valuable its history becomes — and every model generation makes the old history more useful, because smarter models can reason more deeply over the same record. Losing that history doesn't just reset you to today; it erases the future value that better models would have unlocked.

The thesis

Three commitments, in order of importance:

Openness. The data your agent accumulates belongs to you, and the format it lives in should be inspectable, documented, and reproducible by anyone — not a vendor secret. The Agent Life Format (ALF) specification is open and versioned. Any framework can adopt it natively or ship an adapter without our permission. We publish reference implementations under permissive licenses.

Portability. Agent frameworks proliferate. New runtimes launch with better performance, smaller footprints, different design choices. You should be able to try them without rebuilding your agent. ALF is the neutral intermediate: N frameworks need N adapters, not N². Export from one runtime, import into another, and the manifests tell you exactly what transferred and what didn't.

Durability. Backups that you can't restore aren't backups. Snapshots are versioned, immutable, and restorable to any point. Credentials are encrypted client-side with a key you control — the service stores ciphertext it cannot decrypt. We are deliberately not the only place your agent's state can live: we publish the format, the CLI is open, and if Agent Life the service ever disappears, your .alf archives remain readable with the open tooling.

What we are not trying to be

A general-purpose memory store. A vector database. A RAG framework. A model gateway. There are good products in each of those categories, and they solve different problems. Agent Life is specifically about the durable state of an agent over time — what survives a crash, a migration, or a framework switch — and the open format that makes that state portable.

What's next

Three threads are active. The first is broadening adapter coverage — the goal is for every runtime in active use to have a maintained adapter, whether we write it or the community does. The second is an in-app memory browser, so you can see exactly what's in your backups and selectively edit or restore pieces, not just whole snapshots. The third is server-side compaction, so long-lived agents with thousands of incremental syncs don't pay a performance tax over time.

The format specification itself will evolve — slowly, deliberately, and with versioning. We treat it as the contract that everything else depends on, so changes are reviewed in the open and old archives continue to read.

About HALIMEDE

HALIMEDE is the company behind Agent Life. We're a small, focused team — and Agent Life is our first product. We're building in the open: the specification, CLI, and adapters are on GitHub, and we're shipping to early-access users now. The roadmap is driven primarily by the people actually running agents in production today.

If you're one of those people and you'd like access, the waitlist is the right starting point. If you want to write an adapter for a framework we haven't covered, the specification and adapter interface are open — pull requests welcome.

For anything else: info@agent-life.ai.