The iii + AgentMemory Stack: How AI Agents Get Long-Term Memory and Zero-Cost Integration
The Memory Problem
Every developer who's worked with AI coding agents knows the frustration: you spend an hour establishing context, explaining your codebase, setting conventions — and then the session ends. Next time you open a new chat, you're starting from scratch.
This isn't a failure of AI capability. It's a systems problem. LLMs have context windows, not memory.
**AgentMemory** solves this. It's a persistent memory layer for AI coding agents that remembers everything across sessions — decisions made, conventions established, patterns discovered, lessons learned. Built on the **iii engine**, it inherits a mature distributed systems foundation instead of reinventing the wheel.
The Integration Problem
The second hard problem: distributed service integration. Every new service you add to a system potentially connects to every other service. The cost is quadratic. You end up writing the same integration boilerplate over and over — REST clients, queue handlers, webhook receivers, event subscribers.
**iii** solves this by reducing every integration to zero. Workers register with the iii engine and immediately become composable with every other worker. The engine handles discovery, routing, triggers, and state. You write business logic, not plumbing.
Two Tools, One Stack
Here is the key insight: AgentMemory and iii are built to work together. AgentMemory runs as a worker on the iii engine. Its memory operations are trigger-driven events. Its observability is built on iii's tracing primitives. The result is a memory layer that's as robust and distributed as the systems it serves.
How It Works
AgentMemory on iii
AgentMemory registers as an iii worker and exposes functions via the iii trigger system. When an agent stores a memory, it's a function call on the iii bus — meaning any other worker can subscribe to memory events, react to them, or build on top of them.
Claude Code session → AgentMemory (worker) → iii engine → persistent storage
↑ ↓
Recall query other workers
Shared Primitive Set
Both tools operate on the same mental model: **Workers do things in response to Triggers**. The difference is scope:
- **iii** is the infrastructure layer — how services communicate
- **AgentMemory** is the knowledge layer — what services remember
Together they give you a system where services are composable AND remember what they've done.
Benchmarks and Reality
AgentMemory's README shows real-world benchmark comparisons against other memory solutions. The key metrics: recall accuracy, cross-session persistence, and retrieval latency. The implementation extends Karpathy's LLM Wiki pattern with confidence scoring, lifecycle management, and hybrid search (BM25 + vector + knowledge graph).
iii has been battle-tested in production environments — the engine handles the routing, Worker registration is language-agnostic, and the SDKs (TypeScript, Python, Rust) are first-class.
Getting Started
AgentMemory
npm install -g @agentmemory/agentmemory
agentmemory
agentmemory connect openclaw
Your OpenClaw instance now has persistent memory. Say "remember this" to save insights. Say "recall what we discussed about architecture" to pull up past context.
iii
pip install iii-sdk
For service-to-service integration: `registerWorker()` → `registerFunction()` → `registerTrigger()`. That's it.
For OpenClaw Users
This is where it gets interesting. AgentMemory explicitly supports OpenClaw. If you're running OpenClaw as your agent backbone, you can now wire AgentMemory into it and get session-to-session continuity that wasn't possible before.
The memory skills available in OpenClaw:
- **remember** — save insights explicitly
- **recall** — search past sessions
- **forget** — manage what gets retained
- **session-history** — navigate historical context
The Bigger Picture
AI agent development is moving from "one-shot interactions" to "ongoing systems." For that to work, agents need:
1. **Memory** — not just context, but persistent learned knowledge
2. **Integration** — not just APIs, but composable services
iii + AgentMemory addresses both. They are designed to be the foundation layer for agentic systems — the same way databases and message queues are the foundation for distributed applications.
The stack is young but production-ready. The SDKs are stable. The integration points are clean. And because both are open-source with permissive licenses (ELv2 for the engine, Apache 2.0 for SDKs), you can build on them without fear of vendor lock-in.
Resources
- [AgentMemory on GitHub](https://github.com/rohitg00/agentmemory) — npm (`@agentmemory/agentmemory`)
- [iii on GitHub](https://github.com/iii-hq/iii) — PyPI, npm, crates.io (`iii-sdk`)
- Docker: `iiidev/iii`
- Supported agents: Claude Code, Cursor, **OpenClaw**, Gemini CLI, Codex CLI, and any MCP client