0spoon/seamless

An AI coding agent rediscovers the same constraint every session, because
nothing it learns survives the context window. Run two agents against the same
backlog and they pick the same step and build it twice. And the products that
promise to fix this keep your project's memory in someone else's database.
Seamless is a local-first memory and coordination substrate for AI coding
agents. Works with Claude Code, Codex CLI, and any MCP client. It also works
from chats in the Claude desktop app, for long-running work that isn't code:
see Seamless in the Claude app.
It gives a fleet of agents a shared, durable memory and a way to divide work
without colliding: memories with a supersession lifecycle, hybrid recall, a
dependency-aware task queue with lease-based claiming, captured plans, and
research trials. Durable knowledge is stored as markdown files on disk; the
seamlessd daemon indexes it, serves it over MCP, and renders a web console,
while the companion seam CLI gives headless agents a direct interface.
**Full documentation: thereisnospoon.org/docs/**
 ·  Website: thereisnospoon.org (source in
docs/)
Developed and published by Arctop. MIT licensed.
Design principles
- **Built for a fleet, not a lone agent.** Real coordination primitives: a
dependency-aware ready-queue, atomic lease-based task claiming, and plans
composed of notes and steps, so agents divide labor instead of colliding.
- **Files are the source of truth.** Every memory and note is a markdown file
with YAML frontmatter under ~/.seamless -- git-diffable, greppable,
hand-editable. SQLite indexes those files and also stores operational state
such as sessions, tasks, trials, and events, so back up the whole data
directory.
- **Curation proposes, humans dispose.** Every gardener pass -- from
deduplicating and archiving to flagging dead weight and knowledge gaps --
only *proposes*; applying is an explicit action. Supersession preserves
provenance, so nothing is silently rewritten.
- **Small, self-contained runtime.** A static Go daemon and CLI, no CGO,
pure-Go SQLite, no Node, no separate vector engine, no cloud account.
How it compares
The agent-memory space splits into a few recognizable categories. By category,
because categories do not go stale:
| | Seamless | Cloud memory APIs | Built-in agent memory | Knowledge-graph servers |
|---|---|---|---|---|
| Storage format | Markdown files on your disk; SQLite indexes them and stores operational state | Their database, reached by API key | Vendor-managed store inside one product | A graph database, often a separate server |
| Runs where | Your machine, localhost only | Their cloud | The vendor's product | Your machine or theirs |
| Account required | No | Yes | The vendor's | Usually no |
| Multi-agent coordination | Task queue, lease-based claiming, shared plans | None | None -- one agent, one store | Shared reads at best |
| Forgetting policy | Supersession with provenance; a gardener proposes, a human disposes | Automatic summarization you do not control | Vendor-defined | Manual |
| Runtime | Static Go daemon and CLI | HTTP SDK against their service | None (built in) | Node or Python, plus the database |
For the version with product names and receipts, see
the full comparison.
Real transcripts
Four pairs of real, unedited Claude Code sessions -- identical prompt,
identical repo, with and without Seamless:
- **Cold start** -- one
session continues yesterday's plan from an injected briefing; the other