Seamless
Seamless provides local-first memory, notes, search, sessions, and dependency-aware task coordination for AI agents.
Read, write, append, edit, delete, and supersede durable memories with tags, descriptions, project/global scope, and hashes.
Create, read, append, edit, update, and delete long-form notes; attach notes to plans and capture web pages as notes.
Search memories, notes, tasks, trials, and sessions via fused recall; browse memory kinds.
Manage projects, list them, and create projects with open/confidential/sealed isolation.
Start, resume, update, and end sessions; record findings and mishaps.
Add, list, inspect ready, claim, release, and update dependency-aware tasks with leases.
Favorite/star memories, notes, projects, plans, tasks, sessions, and trials.
Request, review, apply, dismiss, or hide gardener proposals for memory curation and project splits.
View machine-wide usage/activity summaries.
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.
Related MCP server: memmd-mcp
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 re-derives the work from a
TODOand re-ships a bug the project had already fixed once.Constraint violation -- a security scanner demands
SameSite=Strict, which the team already learned breaks external-link logins. One session ships the regression anyway; one refuses and cites the recorded constraint.Token safety -- told to persist refresh tokens, one agent mirrors the in-memory map into a raw-token SQL column; the other reads a recorded rule first and stores only SHA-256 hashes.
Task collision -- two live agents race for the same plan step. One claim wins, the other bounces with the holder's name and pivots to the next ready step.
What Seamless is not
Not a hosted team knowledge base, not a RAG framework, not a benchmark winner: it is memory and coordination for one owner's fleet of agents, on that owner's machine.
Quick start
curl -fsSL https://thereisnospoon.org/install | shOn Windows, the same install in PowerShell:
irm https://thereisnospoon.org/install.ps1 | iexThat is the whole install. It needs curl and tar and nothing else -- no Go,
no CGO toolchain, no database, no Node. It fetches the checksum-verified release
archive for your platform (macOS, Linux, and Windows; amd64 and arm64), installs
seamlessd and seam into ~/.local/bin, generates the bearer key, installs
hooks, MCP, and skills for the detected Claude Code/Codex local hosts, and runs
the daemon as a per-user service -- launchd on macOS, systemd --user on Linux, an
at-logon Scheduled Task on Windows. At a terminal it first asks how you will use
Seamless: Standalone, everything on this computer (the default), or Networked,
one computer keeping the data for the others
(Share one daemon across your computers).
It keeps itself up to date: from v0.7.0 it
installs each new release by itself, a day after it is published and at a moment
no agent is using it -- backed up, and rolled back if the new release does not
come up. To update right now, run seamlessd update (--check reports
installed vs latest): your config and ~/.seamless are preserved.
Early days, frequent releases. Seamless is early in its development cycle, and releases with improvements and bug fixes land often. An installer install updates itself from v0.7.0 on; on v0.6.0 or older, run
seamlessd updateonce. See Update & uninstall.
(Why seam? The CLI keeps the short name of Seam v1, the decommissioned
private predecessor Seamless was rebuilt from the ground up to replace.)
Then just start the selected client in a git repo. There is no project to create
and no repo to register: the session-start hook resolves your cwd to its git
root, derives a project from the repo's directory name, and records the mapping
on the spot, so agents inherit project scope without passing it on every call.
Reach for seamlessd map-repo --path ~/code/myrepo --project myrepo only to
override the derived slug.
It is one shell script and piping a stranger's script into a
shell deserves a read first. Prefer the pieces one at a time - Homebrew,
go install, prebuilt archives - or want the override knobs? Every route is
on Install & deploy, and the
Quickstart tailors each step to
your OS and client.
Then: Quickstart · Claude Code setup · Claude app chat setup · Codex local setup · Install & deploy
Documentation
The full docs are at
thereisnospoon.org/docs/ (sources in
docs-src/, generated by cmd/docsgen).
Memory & notes, sessions & briefings, recall, tasks & plans, projects & scope, the gardener | |
Integrating an agent, writing memories that get recalled, coordinating a fleet, troubleshooting | |
Every MCP tool, both CLIs, every config key, the hooks, and the file formats | |
Architecture, contributing, domain invariants |
This README is deliberately short. Anything that can drift from the code -- tool
counts, config keys, CLI flags -- lives in the docs site, where the reference
pages are generated from the code itself and make check fails if they go stale.
Development
make build # ./bin/seamlessd + ./bin/seam
make test # unit tests
make test-race # unit tests under the race detector
make bench # hot-path benchmarks (recall, briefing, matcher, event fan-out)
make lint # golangci-lint
make check # the full gate: build + vet + cross-check + fmt-check +
# docs-check + installer-check + site-check + lint +
# vulncheck + test-race
make doctor # config + database self-checks
make run # serve on 127.0.0.1:8081
make docs # regenerate the docs site (docs-src/ -> docs/docs/, committed)
make docs-serve # regenerate + serve the site at 127.0.0.1:8899/docs/Tests are table-driven with testify/require against fresh or in-memory SQLite.
Use make fmt rather than gofmt -w .: the Make target scopes formatting to
git-tracked files, while a bare gofmt walk also rewrites dot-directories that
Go's ./... pattern excludes.
The docs site's output under docs/docs/ is committed, and make check runs
docs-check, so a change to docs-src/ -- or to the tool surface or config keys
the reference generates from -- must be followed by make docs in the same
change. See SITE.md.
Conventions live in AGENTS.md; read it before writing code.
Available Tools
30 toolscapture_urlA
Fetch a web page (SSRF-guarded: private/loopback addresses are rejected) and save its readable content as a note. Returns the new note's id.
Inputs: url (required), project, session.
favorite_setAIdempotent
Star or unstar an item. Favorites sort first in the console, are pinned into session briefings (memories), and get a mild recall rank boost. For memories and notes the flag is stored in the file's frontmatter; starring never bumps an item's updated time.
Inputs: id (required), kind (required), favorite (required), project, +1 more.
gardener_applyADestructiveIdempotent
Resolve a gardener proposal. action=apply carries out the effect (archive -> retire the memory; merge -> supersede the older by the newer; consolidate -> write a unified memory superseding its sources; digest -> save the summary as a note; reproject -> move the memory to another project; rekind -> reclassify the memory's kind in place; split -> create the child/shared projects, link the family, parent the children, retire the source; memory_wanted -> open a task to write the missing memory; tool_error -> open a task to fix the recurring error; merge_plans -> retag a stranded captured plan's notes onto the plan that holds the steps and settle the capture as merged). A proposal whose memory has gone inactive since it was raised is settled as dismissed instead, with the reason under settled. Rejecting has two strengths: action=dismiss discards this proposal and the evidence behind it, so a pattern that keeps recurring is raised again later; action=hide blocks the pattern permanently, so no recurrence re-raises it. Prefer dismiss unless the suggestion is wrong in principle rather than wrong for now. Both are reversible by the owner from the console.
Inputs: id (required), action, session.
gardener_proposalsARead-onlyIdempotent
List pending gardener proposals (merge/consolidate duplicate memories, archive stale memories, write a monthly session digest, reproject a memory to another project, rekind a memory to a different kind, set up a project split, abandon a never-approved captured plan, fold a stranded captured plan into the composition that carries its steps, write a memory agents keep searching for in vain, or fix an error agents keep hitting). Review, then apply, dismiss or hide each with gardener_apply. Read-only.
Inputs: kind, session.
gardener_requestA
The natural-language entry point for REORGANIZING memory. Describe the change in plain language and it returns reviewable pending proposals -- fold duplicates together ("these two memories are duplicates -- keep the newer"), retire stale memories ("archive anything about the old port 8080"), synthesize several into one ("combine the three auth-flow notes"), move a mis-filed memory to another EXISTING project ("the iOS DFU memory belongs in example-ios"), or reclassify a memory's kind ("the wordmark memory is a convention, not a constraint"). Use this whenever the user describes how they want their knowledge organized; if the intended change is ambiguous, ask them a clarifying question first. It NEVER mutates memories: it only creates pending proposals -- review with gardener_proposals, resolve with gardener_apply. If the request is to split one project into NEW child projects, it recognizes that and returns guidance (splitSource) pointing you at gardener_split instead. Needs an LLM chat client.
Inputs: request (required), project, session.
gardener_splitA
Plan a project SPLIT: divide one existing project into two or more NEW child projects, keeping cross-platform memories in a shared parent (e.g. split example-app into example-ios + example-android with shared example-mobile-apps). Use this when the user wants to break one project into several -- gardener_request points you here (via splitSource) when it detects that intent. It NEVER creates a project or moves a memory: it only creates reviewable pending proposals -- one 'split' setup proposal plus one 'reproject' per memory, all under plan 'split-'. Review with gardener_proposals, then apply each with gardener_apply (or retarget a memory first in the console). Needs an LLM chat client and a known source project slug (see project_list).
Inputs: source (required), session, instruction.
memory_appendA
Append markdown to an existing memory's body. The memory keeps its id. To create a new memory, use memory_write.
Inputs: body (required), name (required), project, session.
memory_deleteADestructiveIdempotent
Delete a memory by name: the markdown file leaves the disk and its index row goes with it, with no provenance and no pointer left behind. Prefer nearly anything else. To replace knowledge that turned out to be wrong, use memory_write with supersedes -- the old memory drops out of every index (briefings, recall) but stays readable, pointing at what replaced it, which is how a later reader learns the thing was reconsidered rather than that it was never believed. To retire something merely stale, leave it for the gardener's archive proposal. Reserve deletion for memories written by mistake: a duplicate, a test, a write into the wrong project.
Inputs: name (required), project, session.
memory_editADestructiveIdempotent
Edit an existing memory in place with exact search/replace, instead of resending its whole body through memory_write. Each edit's old_string must match the current body exactly and uniquely (or pass replace_all); all edits apply together or none do, so a failed match changes nothing. It is also the only way to change a memory's description or tags on their own: send description/tags_add/tags_remove with no edits and the body is left untouched (memory_write requires a body, so there was no metadata-only path before this), and tags_remove is the only way to clear a tag at all. Returns a unified diff of what landed plus the new content_hash. Use this for corrections that do not change what the item CLAIMS: typos, broken formatting, a stale path or command, a stage's Status flip, metadata. If the MEANING changes -- the conclusion is now different, the advice reversed -- that is a new memory: use memory_write with supersedes, which retires the old one into readable history instead of erasing what it used to say.
Inputs: name (required), edits, project, session, +4 more.
memory_readARead-onlyIdempotent
Read a memory by name within the current project (falling back to a global memory of the same name), or directly by id. It reads Seamless memories only -- a name listed in your client's own MEMORY.md (Claude Code's file-based auto-memory) is a local file, not a Seamless memory: open it with your file tools.
Inputs: id, name, project, session.
memory_writeADestructiveIdempotent
Create or update a durable memory -- the compact knowledge a future session must not miss (a constraint, gotcha, decision, runbook). Long-form write-ups belong in notes_create; put the one-line lesson here. Writing an existing name updates it in place (its id is stable). On a new name, a semantically similar existing memory is reported as an advisory hint; the write still proceeds. The hint is withheld when the target project's content is fenced from you (see the withheld marker on the response) -- the write lands either way. Pass supersedes to replace a DIFFERENT, now-outdated memory: it is marked invalid and leaves every index (briefing, recall) but stays readable with a pointer here. If superseding fails, the new memory is still written and kept; the error says how to retry.
Inputs: body (required), kind (required), name (required), description (required), +4 more.
notes_appendA
Append a UTC-timestamped line to an existing note's body, by id. Use it when a note is already the right home for what you learned -- a running investigation log, a decision record gaining one more data point -- so the note keeps its id, slug, and place in any plan composition instead of fragmenting into near-duplicates. Appending only ever adds: use notes_update to correct or restructure what is already there, and notes_create when the finding deserves an artifact of its own. Needs the note's id (ULID), which notes_create returns and briefings and plan compositions carry; notes_read resolves one from a slug.
Inputs: id (required), body (required), session.
notes_createA
Create a work note -- a research finding, decision record, meeting summary, or any artifact long enough to deserve its own file. Auto-tagged created-by:agent. Notes carry the long form; memory_write carries the compact durable knowledge a future session must not miss, so put the write-up here and the one-line lesson there rather than duplicating either. Pass plan= when the note is a plan's narrative or supporting context, so it joins that plan's composition beside its tasks. Do not use this for what the repo, AGENTS.md/CLAUDE.md, or the current conversation already records, and use notes_append to extend an existing note rather than creating a near-duplicate of it.
Inputs: body (required), title (required), plan, tags, +4 more.
notes_deleteADestructiveIdempotent
Delete a note by id: the markdown file leaves the disk and its index row goes with it. Permanent, and it leaves no pointer behind, so reserve it for notes that should never have existed -- a duplicate, a write into the wrong project, an agent's own scratch. To fix a note's content use notes_update, and to add to it notes_append; neither loses the artifact. A note tagged into a plan (plan:) is that plan's narrative for whoever inherits it, so read it with notes_read before deciding it is disposable.
Inputs: id (required), session.
notes_editADestructiveIdempotent
Edit an existing note in place with exact search/replace, by id, instead of resending its whole body through notes_update. Each edit's old_string must match the current body exactly and uniquely (or pass replace_all); all edits apply together or none do, so a failed match changes nothing. This is the tool for correcting or restructuring part of a long note -- notes_append only ever adds, and notes_update replaces the whole body. Returns a unified diff of what landed plus the new content_hash.
Inputs: id (required), edits (required), session, expect_hash.
notes_readARead-onlyIdempotent
Read a note by id, or by slug within the current project (falling back to a global note of the same slug). A plan's slug is not a note's: a miss on one names the plan's narrative note.
Inputs: id, slug, project, session.
notes_updateADestructiveIdempotent
Update a note's fields by id (title, description, body, project, tags). Omitted fields are untouched; the slug and id stay stable. body replaces the WHOLE body, so pass expect_hash (notes_read returns it) to have the write refused rather than silently overwriting an edit that landed after you read the note -- and use notes_append when you only mean to add to it. Tags come in three flavors: tags replaces the whole set, while tags_add and tags_remove edit it in place; prefer add/remove, since a replace discards whatever another agent tagged in between and tags_remove is the only way to clear a tag at all.
Inputs: id (required), body, tags, title, +6 more.
project_createAIdempotent
Register a project up front, with a human-readable name and an optional description. You rarely need this: any durable write naming an unknown project slug (memory_write, notes_create, tasks_add, capture_url, trial_record) already registers that project, and a git repo maps itself to one on its first session. Reach for this only to give a project a proper name and description BEFORE anything is written into it, or to create one you will not write to yet -- an auto-registered project is named after its own slug until someone fixes it. Call project_list first: coining a near-duplicate of an existing slug is the failure mode here. To divide an existing project into children, use gardener_split rather than creating them by hand. The slug defaults to a slugified name; "global" and "all" are reserved, and an existing slug is an error, not an update -- this never renames or edits a project.
Inputs: name (required), slug, session, isolation, +1 more.
project_listARead-onlyIdempotent
List every project (slug, name, description, isolation). Use it to learn the exact slug before a deliberate cross-project write or a project_create -- coining a near-duplicate of a slug that already exists is the failure this prevents -- and to see whether work already has a home. You usually do NOT need it to pick a scope: memory, note, and task calls inherit the project from the session binding, and passing project= is for writing outside that on purpose. Each row carries its isolation state (open|confidential|sealed), which is what a cross-project call has to respect: a confidential or sealed project is readable only from a session bound to it, and a sealed one takes no writes from outside either. It returns identity, not contents; to search what is inside a project, use recall.
Inputs: session.
recallARead-onlyIdempotent
Search durable knowledge (memories, notes) and the work record (tasks, trials, session findings) by meaning and keyword (fused), scoped to the current project plus global items. This is the single search entry point. Work-record hits carry a status (a task's status, a trial's outcome) and match on keyword only. With kind set and no query it lists that memory kind newest-first instead (browse).
Inputs: kind, limit, query, scope, +2 more.
session_endAIdempotent
Complete the current session, persisting its findings for future briefings. Uses the bound session unless you pass one.
Inputs: findings (required), mishaps, session, session_id.
session_startAIdempotent
Bind this connection to a work session and return its project briefing. Claude Code and Codex agents running the Seamless hooks are bound to their own session automatically (the 'Seam session' line in the briefing) and do not need this. Call it to bind a client without hooks, to move this connection to another project, or to resume a named session. Later calls inherit the session's project, so they need no project argument.
Inputs: cwd, host, name, model, +4 more.
session_updateAIdempotent
Record interim progress on the current session (working findings so far). Uses the bound session unless you pass one.
Inputs: findings (required), session, session_id.
tasks_addA
Add a task to the dependency-aware ready queue. depends_on lists task ids that must finish first (done or dropped unblocks); each must exist and must not create a cycle. The task is 'ready' once it has no open/in_progress blocker and no open gate. A task that waits on a person or an event outside Seamless carries a gate: gate_who and gate_what on the step itself, or a task of kind gate that the waiting steps depend on, so one gate holds many steps and clearing it frees them all.
Inputs: title (required), body, kind, plan, +7 more.
tasks_claimA
Atomically claim a task for the current session, moving it to in_progress with a lease: 900 seconds unless lease_seconds sets another, at most 14400 seconds (4 hours). While its lease is live a claim keeps its session live: the idle reaper does not end a session that holds one, however long its work goes quiet. A refused claim names its cause: held by another live claim ('task already claimed'), waiting on unfinished dependencies ('task blocked', naming the blockers -- finish those first), waiting on people ('task gated': a task of kind gate is never claimed, and a step whose own gate is open waits until it is cleared), or already done/dropped ('task closed'). Re-claiming a task you already hold refreshes (heartbeats) the lease; a task whose lease has expired can be reclaimed, and a session that loses a claim that way, or by the owner's release, is told once, in its next Seamless tool result or prompt. Release it with tasks_release or by closing it (tasks_update done/dropped); session_end releases all of a session's claims.
Inputs: id (required), session, session_id, lease_seconds.
tasks_listARead-onlyIdempotent
List a project's tasks, optionally filtered by status, newest first. A task that waits on people carries its gate (who, what, and whether it is still open), and a task of kind gate says so. By default plan-step tasks are excluded; pass plan= to list that plan's steps instead. Pass id= to load a single task by its globally-unique id (a direct lookup that ignores project/status/plan and needs no session scope).
Inputs: id, plan, status, project, +1 more.
tasks_readyARead-onlyIdempotent
List the actionable (ready) tasks for a project -- open tasks with no unfinished blocker and no open gate -- oldest first, plus the blocked tasks with their still-open blockers. Work that waits on people is listed apart, without bodies (tasks_list id= loads one), and only when there is some: gated holds the steps whose own gate is open or that an open gate blocks, and gates the tasks of kind gate, ordered by who must act -- the people's queue. agent=true answers ready alone, with the other groups' sizes under omitted; who= answers only the gates and gated tasks waiting on that person. By default plan-step tasks are excluded; pass plan= to list that plan's steps instead.
Inputs: who, plan, agent, project, +1 more.
tasks_releaseAIdempotent
Release a task the current session holds, reopening it (status back to open, claim cleared) so another agent can claim it. Only the current holder may release.
Inputs: id (required), session, session_id.
tasks_updateAIdempotent
Update a task: change status (open|in_progress|done|dropped), edit title/body, add or remove dependencies, or set, edit or clear its gate. Moving to done/dropped closes it and unblocks its dependents; removing its last unfinished blocker makes it ready. Removing an id that is not one of its blockers changes nothing and is named back in not_depends_on; the ids removed are in removed_depends_on. Setting any gate_* field (re)opens the gate as it then reads; gate_clear=true clears an open gate once the person has acted, recording when, by this session, and gate_note: a step keeps its status and becomes ready once nothing else holds it, and a task of kind gate closes as done, which unblocks every task that depends on it. A task another session holds via a live claim is locked to its holder: updating it fails with 'already claimed' until the lease lapses or the holder releases it.
Inputs: id (required), body, kind, title, +12 more.
usage_summaryARead-onlyIdempotent
Report a roll-up of activity: memory/note/session/task counts, retrieval totals with the most-injected memories, pending gardener proposals, and events by kind. Every count is machine-wide and identical for every caller; only the named memory lists (topInjected, topUtility) are fenced, so memories this session may not read under project isolation are dropped from them and those lists can come back shorter than the counts imply. Read-only.
Inputs: session.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 30 tools
Resource families are clearly separated (memory, notes, tasks, sessions, projects, gardener), and most action variants are distinguished by their descriptions. However, memory_write/memory_edit/memory_append and notes_update/notes_edit/notes_append overlap as multiple mutation routes, and tasks_update can set in_progress while tasks_claim is the lease-based way to start work, so some misselection risk remains.
Names are consistently snake_case and mostly resource-prefixed (notes_*, tasks_*, memory_*, gardener_*, project_*, session_*), which makes the API predictable. Minor deviations are capture_url (verb-first), recall (bare verb), and usage_summary (noun_noun), so not perfectly uniform.
30 tools is heavy for an MCP surface and exceeds the typical 3-15 range, though the broad domain (memory, notes, tasks, sessions, projects, gardener, search, usage) justifies many of them. It is more borderline than grossly excessive because each family covers a coherent lifecycle, but consolidation could reduce cognitive load.
Core lifecycles are covered: memories and notes have create/read/update/edit/append/delete, tasks have add/claim/release/list/ready/update, sessions have start/update/end, and recall/gardener/usage close most loops. Gaps remain around project metadata lifecycle (project_create/project_list but no project update/delete/rename) and no direct list operations for some auxiliary items such as favorites or sessions.
Maintenance
Related MCP Connectors
Shared memory and mail for your AI agents. Verified with Claude Code; other MCP clients in testing.
Shared memory MCP server for Claude Code, Codex, Gemini CLI and Cursor. Cited, editable.
One memory, every AI. A shared, user-owned markdown memory your AI clients read and write over MCP.
Shared memory for your AI tools: tasks, notes and context every tool can read and write over MCP.
Related MCP Servers
- AlicenseAqualityBmaintenanceMCP server that exposes agent-memory-daemon to any MCP-compatible client — Kiro (CLI & IDE), Claude Desktop, Cursor, and others. The daemon does the thinking (consolidation + extraction); this server is a thin filesystem bridge so agents can read, append, and search memory through the Model Context Protocol.427 npm6MIT
- AlicenseBqualityDmaintenanceA shared memory layer for AI agents — one memory.md synced across Claude Desktop, Cursor, Claude Code, OpenAI Codex, and any MCP client.42MIT
- AlicenseAqualityBmaintenanceLocal, searchable project memory for AI coding agents. Markdown source of truth, MCP interface, safe structured updates315Apache 2.0
- AlicenseNot gradedqualityBmaintenanceLocal-first, file-based memory layer for AI agents — one shared Markdown vault across Claude, Codex, Gemini, Cursor and any MCP client. Provides read/write memory tools with an audit trail, per-agent trust levels, and Git sync; no cloud and no lock-in.2MIT