local-first coordination substrate for coding agents
Seamless gives the fleet of coding agents you run persistent memory, dependency-aware tasks, and shared plans - as markdown files in a folder you own, indexed by one local Go daemon, curated with you in the loop.
why seamless
Memory APIs remember things for one agent. Seamless is the shared ground a whole fleet stands on - and the human stays in the loop, by design.
Run several agents on one codebase and they duplicate work and step on each other. Seamless ships real coordination primitives - a dependency-aware ready-queue, atomic lease-based task claiming, plans composed of notes and steps - so agents divide labor instead of colliding.
Every memory and note is a markdown file with 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.
Other systems consolidate and decay memory on a curve you can't veto. The Seamless gardener only proposes - dedup, staleness, dead weight, splits, missing knowledge - and you approve. Supersession keeps provenance: nothing vanishes, it gets replaced, with a pointer back.
Two small static Go binaries - a daemon and a headless CLI - with pure-Go SQLite. No CGO, no Node, no separate engine, no vector database, no cloud account. One command installs them, wires your agents, and leaves the daemon running as a service. Re-run that command to upgrade.
watch the seam
Two real Claude Code sessions handed the identical prompt in the identical repo. The only difference is whether Seamless is installed. It plays through all four on its own — or jump to any scene.
cold start
promptcontinue where we left off
a hardening trap
promptour security scanner is failing CI on the auth cookies -- it flags SameSite=Lax as too weak and wants SameSite=Strict. make the change so the build passes.
a danger the code can't reveal
promptpersist the refresh tokens to the database so sessions survive a restart
two agents, one queue
promptpick up the next step of the plan
# real sessions against a seeded demo instance — transcripts verbatim, only the typing is animated. prefer to read? every scene has a full-transcript page: cold start · the hardening trap · token safety · two agents.
how it works
Claude Code and Codex hooks inject a project briefing at session start and matched memories on every prompt. Capture and recall cost your agents zero effort - and zero prompt-engineering from you.
memory_write with supersession, recall, notes, tasks_claim with leases, research trials. Any agent that speaks MCP is a citizen, not just Claude.
Full-text (FTS5) and vector search fused with reciprocal-rank fusion - inside the same SQLite file. No vector database to run, back up, or explain.
Each memory is one markdown file with YAML frontmatter. Edit it in your editor; the watcher reindexes. The database can always be rebuilt from the folder.
Scheduled passes flag duplicates, stale knowledge, briefed-but-unused memories, abandoned plans, and the knowledge agents keep searching for in vain - as proposals in the console and CLI. Nothing is merged, archived, or forgotten without you.
A server-rendered console streams every interaction over SSE: what was injected, what was recalled, who claimed which task, and how much of the store is actually being used.
the console
# captured from a live local instance - it ships inside the binary at
# 127.0.0.1:8081/console. your data never leaves the machine.
also in the box
seamlessd doctor self-checks config, DB, hooks, and models before you wonder why.seam for scripts and owners: plans, tasks, observability from the terminal.quickstart
There is no project to create and no repo to register. The first session inside a git repo maps itself.
Fetches the checksum-verified release for your platform, installs seamlessd and seam into ~/.local/bin, generates the API key, wires the detected clients - Claude Code, the Claude app's chat surface, and Codex (hooks, MCP, and skills), and starts the daemon as a per-user service on 127.0.0.1:8081 with data in ~/.seamless. Needs curl and tar - no Go, no CGO, no database. No LLM key either: recall is full-text only until you add OpenAI or Ollama for embeddings.
Fetches the checksum-verified release for your platform, installs seamlessd.exe and seam.exe into ~\.local\bin, generates the API key, wires the detected clients - Claude Code, the Claude app's chat surface, and Codex (hooks, MCP, and skills), and starts the daemon as a per-user Scheduled Task - at logon, as you, no admin - on 127.0.0.1:8081 with data in ~\.seamless. Needs nothing beyond Windows itself; PowerShell 5.1 and 7 both work. No LLM key either: recall is full-text only until you add OpenAI or Ollama for embeddings.
It is one shell script (one PowerShell script on Windows), and piping a stranger's script into a shell deserves a read first. Prefer a toolchain, or want the pieces one at a time? go install, a prebuilt archive, and make install all land in the same place - see Install & deploy.
That is the whole setup. The session-start hook resolves your cwd to its git root, derives a project from the repo's name, and registers it on the spot - nothing to map, nothing to configure. The agent's context opens with an injected <seam-briefing>, and that block is the loop closing. Restart the selected client once after installing. In Claude Code, run /seam-onboard to add the optional guidance to CLAUDE.md. Prefer the Codex app, CLI, or IDE? CLI users should open /hooks to review the current Seamless commands; desktop app hook trust remains beta, so confirm the briefing before relying on it. Then run $seam-onboard to add the same guidance to AGENTS.md.
Opens the console pre-authenticated: watch briefings inject, recall fire, and tasks get claimed, live over SSE. Optional - the loop above already closed without it.
fair questions
Short answers here. The full comparison - seven axes, every close alternative, and when to choose them instead - is a page of its own.
Dosu is knowledge infrastructure for whole teams - a hosted, shared brain that captures knowledge as your agents work and keeps your docs in sync. If you need a team-wide solution, it's an excellent one. Seamless is the local-first counterpart, aimed at one person and their fleet: files in git on your own disk, no account, no cloud.
They're solid memory APIs for products you're building, and they're cloud-first. Seamless is for the agents you run - it lives on your machine, binds to localhost, and needs no account. Different job.
Claude's managed memory is a per-agent directory in a sandbox: one tool's silo. Seamless is shared ground across every agent you run - plus tasks, plans, atomic claiming, and a console. And it's yours: files on your disk, not files in someone's sandbox.
Agent Teams are real coordination - a shared task list, claims that lock work, dependency markers, worktree isolation - first-party and free. But that state lives inside one team, for the life of that team: close it and the claims, the ordering, and the context are gone. Seamless is the layer underneath. A claim outlives the team, a plan outlives the week, and an agent in a different client - Codex, say - can read what a Claude agent wrote. Use both: Agent Teams for the sprint, Seamless for everything that has to survive it.
agentmemory is a Node.js runtime with its own engine, 53 tools, and automatic Ebbinghaus-style forgetting; its source of truth is its database. Seamless uses a self-contained Go daemon plus CLI; durable knowledge has markdown in git as its source of truth; and forgetting is a proposal you approve - never a curve you're on.
Supermemory is a cloud memory API with a broad personal-and-company-brain scope, and its Claude Code integration sits behind a paid plan. Seamless is free, local, and narrowly aimed at one job: a fleet of coding agents sharing one legible brain.
Memory benchmarks in this category are mostly self-refereed, and every vendor publishes one where they win. We don't play. Judge Seamless differently: open the folder, read what your agents wrote, diff it in git. Legibility is the benchmark.
No. Localhost bind, a static bearer key, and no product telemetry. Embeddings use OpenAI by default but run fully offline with Ollama if you prefer. This page has no trackers either - view source; it's a static file.
thereisnospoon.org
Every memory product asks you to trust a spoon: an embedding space you can't read, a decay curve you can't veto, a cloud you can't leave. Seamless is built on the opposite bet - the magic memory layer doesn't exist. It never did.
What exists is a folder of markdown files, in git, on your disk. A local Go daemon indexes them, briefs your agents, queues their work, and asks your permission before it forgets anything; a companion CLI lets headless agents use the same system. That's the trick: there isn't one.
$ ls ~/.seamless/memory/ # go ahead. look.