Skip to main content
Glama

Seamless

Go Reference Latest release License: MIT MCP

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 TODO and 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 | sh

On Windows, the same install in PowerShell:

irm https://thereisnospoon.org/install.ps1 | iex

That 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 update once. 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).

Concepts

Memory & notes, sessions & briefings, recall, tasks & plans, projects & scope, the gardener

Guides

Integrating an agent, writing memories that get recalled, coordinating a fleet, troubleshooting

Reference

Every MCP tool, both CLIs, every config key, the hooks, and the file formats

Internals

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 tools
capture_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_setA
Idempotent

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_applyA
DestructiveIdempotent

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_proposalsA
Read-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_deleteA
DestructiveIdempotent

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_editA
DestructiveIdempotent

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_readA
Read-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_writeA
DestructiveIdempotent

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_deleteA
DestructiveIdempotent

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_editA
DestructiveIdempotent

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_readA
Read-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_updateA
DestructiveIdempotent

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_createA
Idempotent

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_listA
Read-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.

recallA
Read-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_endA
Idempotent

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_startA
Idempotent

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_updateA
Idempotent

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_listA
Read-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_readyA
Read-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_releaseA
Idempotent

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_updateA
Idempotent

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_summaryA
Read-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

    A3.9/5.0

    Scored across 30 tools

    Disambiguation4/5

    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.

    Naming Consistency4/5

    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.

    Tool Count3/5

    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.

    Completeness4/5

    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

    ActivityActive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      MCP 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.
      4
      27 npm
      6
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      A shared memory layer for AI agents — one memory.md synced across Claude Desktop, Cursor, Claude Code, OpenAI Codex, and any MCP client.
      4
      2
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Local, searchable project memory for AI coding agents. Markdown source of truth, MCP interface, safe structured updates
      3
      15
      Apache 2.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Local-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.
      2
      MIT