lockstep
Lockstep is a team decision-and-coordination MCP server for coding agents, centered on a shared ledger of decisions, changes, dependencies, questions, and tasks.
Publish changes to a project change feed, optionally tied to a surface and contract delta, with risk tiers controlling immediate delivery vs. confirmation.
Route changes by blast radius to repos that declared dependencies on affected surfaces.
View and acknowledge inbox items including changes, questions, tasks, decisions, and conflicts.
Search the ledger with natural-language queries over decisions, changes, and answered questions.
Ask and answer team questions, with optional surface scope and urgency flags.
Delegate and complete tasks assigned by GitHub login, notifying assignees through their inbox.
Propose, list, and acknowledge decisions with versioned optimistic concurrency, rationale, alternatives, review dates, and binding status.
Declare surface dependencies so changes reach consuming repos, and list consumers of a surface.
Find file owners from the repo's CODEOWNERS snapshot.
Read product constraints and governed surfaces for a capability, surface, or text scope.
Set feature context locally so later decisions and changes attach to the right capability.
Check working-tree diffs against accepted decisions for possible contradictions, when hosted checks are enabled.
Get session briefings on what changed and what is binding since the last session.
Refresh local decision packs and sync managed organization skills into the checkout.
Integrates with GitHub for authentication and repository connection, enabling GitHub sign-in, linking repos to a shared project, and running a PR-time reconciliation gate through a GitHub Action.
Yesterday, you and Claude renamed POST /login to POST /session. Today, a fresh session writes a client against the old route. The decision was made; the next session never received it.
CLAUDE.md is one file in one repo, and auto memory lives on one machine. Neither knows what a teammate decided yesterday, the rule your PM approved, or the standard your lead published last week. Lockstep gives the whole team one decision record — and briefs every agent on it before it acts.
Can your team answer these six questions about any important change?
What request started this?
What evidence supported it?
Who made the decision?
Who approved it?
What did it replace?
Is it still true?
If the answer lives in Slack, a PRD, or someone's memory, your agents don't have it either. Lockstep records each answer with its source — and briefs the next session on it.
One record, three ways in:
Developers: keep accepted decisions across Claude Code sessions and check whether changed code may contradict them.
Product managers: turn a product brief into reviewed requirements, track revisions, and copy a useful implementation brief before a developer joins.
Engineering leaders: publish standards and skills once, roll them out to every engineer's Claude Code by team, repo, or path, and see which version landed where (Standards & Skills).
Teams: share the same ledger, route interface changes to affected services, and retain existing integrations, permissions, and PR enforcement.
For example, accept “exports expire after 24 hours, except internal previews.” A later Claude session receives that decision without another explanation. A PM can trace the requirement to its source, revise it for review, and share its accepted version with a developer.
Start with one real repo or brief. Invite a colleague when there is useful context to share; company-wide onboarding is not required.
npx lockstep-cli onboardHow it compares
Lockstep is not session memory. Session memory explains what one agent saw or tried; Lockstep keeps the team decisions that remain true across sessions, models, repositories, and people.
Nothing | CLAUDE.md in git | Session memory (e.g. claude-mem) | Lockstep | |
Records a decision with owner + approval | ❌ | Manual | ❌ | ✅ |
Versions a decision when it's replaced — the old one stays visible | ❌ | ❌ | ❌ | ✅ |
Briefs the next session on what's binding | ❌ | Whole file, unranked | Recalls past context | ✅ Ranked by blast radius |
Routes a change to the services that consume it | ❌ | ❌ | ❌ | ✅ Dependency graph |
Fails a PR that contradicts a binding decision | ❌ | ❌ | ❌ | ✅ PR-time gate |
"Does anyone use this endpoint?" answered instantly | Manual | Manual | ❌ | ✅ From the graph |
How It Works
Start with your own next session:
You accept: “Use POST /session; POST /login is retired.”
→ Lockstep keeps the accepted decision.
→ Your next Claude session receives it before you start coding.
→ An opted-in check can flag changed code that may contradict it.A decision is a durable rule or architectural choice that shapes future work. A change is a routine event — captured, but only surfaced when it matters. A PM can establish the same continuity by reviewing requirements from a brief before any code is connected.
As teammates join
The same ledger grows into coordination across developers and repos. For example, a route change in one service can reach the developers whose services consume it:
Dev A's agent Lockstep Dev B's agent
───────────── ──────── ─────────────
logs a decision ───────▶ ┌─────────────────┐
"auth → /session" │ Decision ledger │
│ Usage graph │ blast radius
changes a surface ──────▶ │ Impact ranking │ decides who
POST /session │ Inboxes │ cares & how much
└────────┬─────────┘
│ routes to the services that
▼ consume the changed surface
Dev B's next session begins with:
⚠ [impact 3] auth: /login → /session (binding)
→ B's agent uses /session before writing a lineCapture — A coding-agent hook diffs the working tree and publishes changes with a canonical surface ID (
http:POST /session,proto:auth.v1.Auth/Login). When an agent makes a real decision, it logs it withpropose_decision.Rank — Each decision and change gets an impact score = how many services consume the affected surface (its blast radius). This is what keeps signal high and noise quiet.
Route — Changes fan out to exactly the repos that declared a dependency on the changed surface (
lockstep.yaml). The agent can also askconsumers("http:GET /orders/:id")— "does anyone use this?" — and get an answer from the graph instead of pinging a human.Replay — On session start, each agent receives a briefing of what changed and what's binding since it was last here, highest blast radius first — so it's aware before it acts.
Bind — Cross-cutting decisions (high impact) stay open until an affected team acknowledges them; own-area decisions bind on assertion. A PR-time gate fails any contract change with no binding decision.
Related MCP server: Kage
Quick Start
Choose your starting point: developer or product manager. Both use the full dashboard and the same project history.
Status: pilot. CLI 0.4.0 is on npm and the hosted dashboard. Session briefings, hooks, and managed skills support Claude Code today; any MCP client can call the tools, and other agent adapters are on the roadmap.
For developers
Requires Node.js 20+, Claude Code, a GitHub account, and a Git repo with an origin remote.
cd your-project
npx lockstep-cli onboardPreview locally. Inspect candidate documentation and proposed Claude configuration changes before approving setup. Select which documents to upload, or skip import and enter a decision manually.
Connect, scan, and review. Sign in with GitHub and connect the intended project. Onboarding runs
scan --apply: it writes or mergeslockstep.yaml, preserving existing entries, and seeds the graph with detected produced surfaces and matched dependencies. Then review up to five decision proposals. Remaining drafts stay in Review. Imports do not become accepted decisions automatically.Choose hosted checks separately. Automatic code checks have their own remembered opt-in. Declining them leaves decision continuity available.
Open Claude Code. Approve the project MCP server when prompted. Onboarding distinguishes configured, connected, decisions ready, and agent verified. Use
npx lockstep-cli statusto inspect configuration and recorded agent verification. Configuration alone is not activation.Return, share, and invite. Later sessions receive current decisions and relevant updates. Use the dashboard's Preview decision brief → Copy decision brief, or print Markdown with
npx lockstep-cli brief. When the scan finds outbound calls with no declared producer and relevant Git history, onboarding also suggests recent contributors to the calling files and prints an invite command.
For example, an unmatched http:POST /billing/charge call in src/checkout.ts can point you to a colleague who recently edited that file. These are leads to ask about the missing dependency, not verified owners; an unmatched call may also target an external service. Confirm the GitHub handle and invite each person you choose:
npx lockstep-cli invite <github-handle>Suggestions do not send invitations automatically. You can share a useful brief with the colleague first.
npx lockstep-cli onboard --dry-run # preview without configuring or uploading
npx lockstep-cli check --upload # explicitly authorize this one working-diff check
npx lockstep-cli check --base main --upload
npx lockstep-cli checks on # enable automatic hosted checks for this checkout
npx lockstep-cli checks off # disable them independently of the ledgerFor non-interactive runs, authenticate first and use --yes to proceed beyond preview:
npx lockstep-cli onboard --yes --no-docs --disable-checks
npx lockstep-cli onboard --yes --upload-docs --docs CLAUDE.md,docs/adr/auth.md --disable-checks--yes approves setup; it does not authorize document uploads or enable hosted checks. --no-docs skips documentation import, while --upload-docs explicitly authorizes uploading the selected candidate documents (--docs narrows that selection). Neither skips the repository scan and graph setup. Non-interactive imports remain drafts for dashboard review. Use --enable-checks or --disable-checks to set check consent explicitly; otherwise saved consent is retained.
Checks are advisory and report completed, partial, skipped, or unavailable. Missing providers or applicable rules do not produce a pass. Automatic checks have a six-second API deadline and never block Claude. Raw diff hunks are processed transiently; stored results contain status, decision references, locations, and feedback.
Onboarding respects LOCKSTEP_API_URL and saved API settings; hosted is the default only when neither exists. Generated Claude commands use a version-pinned npm invocation, so a global Lockstep installation is unnecessary. Decision packs stay local and Git-ignored.
For product managers
Start with a brief, without a repo, CLI, or developer. Sign in with GitHub at the dashboard, then:
Create a project. Use Start with one product brief on the dashboard home page. New pilot projects enable the product layer; joining an existing project preserves its settings.
Paste your brief in Sources. Give it a title and, optionally, a feature reference such as
feature:private-exports. Save it and inspect the extracted requirements alongside their source evidence. If extraction is unavailable, open the saved brief and use Select requirements manually to choose exact source passages.Review and ratify. Inspect the source, set its state to active when ready, and edit, reject, or ratify requirements through Review and Decisions. Drafts and questions remain distinct from accepted requirements.
Use the implementation brief. Open the source and choose Preview implementation brief, review the Markdown, then Copy implementation brief. It includes accepted requirements, rationale and source references, drafts, unresolved questions, and recorded concerns. You have a useful handoff before anyone installs Lockstep.
Revise with history. Edit the saved source when the product brief changes. Previous source versions remain available; changed requirements return to review before the accepted brief is regenerated. Pasted briefs are manually maintained, not synchronized with an external document.
Invite a developer when ready. Use Members & Repos to invite their GitHub handle to this exact project. Share the brief and its project/feature connection command. Their Claude sessions can then receive the relevant ratified requirements.
For example, a PM can start with “exports expire after 24 hours; internal previews are exempt; bulk downloads are out of scope.” Review those requirements, leave “Should expiry be configurable?” as an unresolved question, and copy the implementation context before involving engineering.
Once development is connected, use the existing decision, feature, check, and activity views to review recorded context and concerns. Delivered requirements and no recorded concerns do not mean a feature is complete. Useful-concern, false-positive, and intentional-exception feedback does not silently change a decision.
Copying Markdown does not publish it, send a message, or grant access. Dashboard links remain authenticated. A product colleague joining a developer-created project uses the same dashboard and ledger, with no CLI setup.
Join an existing project
After the project owner invites your GitHub handle, sign in again to activate the invitation. Developers connect their repo to the supplied project ID:
npx lockstep-cli onboard --project-id <project-id> --feature feature:private-exportsOmit --feature when no feature is selected. This reuses the project's ledger and history. Each developer installs personal Claude hooks; product colleagues work in the dashboard.
For teams and self-hosting
Existing B2B integrations, roles, review requirements, and GitHub PR checks remain available. The new semantic code checks are advisory; they do not replace the existing contract gate. The individual pilot starts with Claude Code; other adapters are deferred.
Onboarding already runs scan --apply to establish lockstep.yaml and seed the surface graph. When routes or dependencies change, use npx lockstep-cli scan to preview updates and npx lockstep-cli scan --apply to merge and sync them. The standalone command also retries a scan that was incomplete during onboarding. See lockstep.example.yaml. Independent login, init, connect, scan, and pack commands remain available.
git clone https://github.com/lockstep-team-agent/lockstep.git
cd lockstep
cp .env.example .env
docker compose up --build # Postgres + API (:8080) + dashboard (:3000)Point the CLI at your server:
npx lockstep-cli login --api http://localhost:8080For local development with the dev-login bypass enabled, use:
npx lockstep-cli login --api http://localhost:8080 --dev --dev-id 1 --dev-login aliceThe API needs an extraction provider (ANTHROPIC_API_KEY, or the existing TYPESAFE_API_KEY provider) for automatic imports, and TYPESAFE_API_KEY for advisory checks. Manual requirements remain usable without extraction. Set LOCKSTEP_CHECKS_ENABLED=0 to disable semantic checking server-side without disabling the ledger or existing B2B PR checks.
For production, configure real GitHub authentication, set NODE_ENV=production and LOCKSTEP_DEV_LOGIN=0, apply migrations, and verify provider configuration, request limits, backups, and both onboarding paths. See DEPLOY.md.
What flows through Lockstep
Object | What it is |
Decision | A durable rule or architectural choice. The hero. Impact-ranked, versioned (CAS). |
Change | A routine event on a canonical surface. Routed to consumers by blast radius. |
Question | A cross-team ask, ideally answered from the ledger before a human is pinged. |
Task | Delegated work, fanned out to the assignee's inbox. |
Standards & Skills (organizations) — Claude Code pilot
Behind LOCKSTEP_STANDARDS=1 (see DEPLOY.md), an organization can define how agents should work and prove what reached each checkout. This is a Claude Code pilot, not the complete PRD: pausing/resuming a rollout, Codex, enrolling a repo-free PM workspace, readiness checks for a skill's declared tools, owner reassignment and linking supporting decisions in the standard editor, and author-facing conflict flagging are not built yet. The Map graph shows the first page of an expanded domain (the Outline lists everything).
Standards & Skills — versioned standards (requirements with stable keys and required/recommended levels), skills authored in Lockstep or imported from a public GitHub repo at an exact commit, and checks (PRD sections, PRD rubric, advisory code review). Published versions are immutable; members draft and propose, owners/admins publish.
Rollouts & Adoption — assign exact versions by project, repository, team or person, path and task type; preview the impact before applying; pilot, expand, roll back, retire or withdraw. Adoption reports coverage, installation, session availability, invocation (reported as unobservable where the agent can't show it) and check outcomes separately.
In the work — enrolled checkouts (
lockstep enroll) receive managed skills in.claude/skills/lockstep-org-*/(kept out of git, verified by hash, never executed, never overwritten when edited locally). Session briefings list the applicable requirements with exact versions and point to the relevant skills; the copyable project brief carries the same for repo-free PRD work. Exceptions are requested and approved per requirement, bind to the exact published version (a new version needs a new review), and expire on their own.
Agent | Install managed skills | Session availability | Invocation | Checks |
Claude Code (verified on 2.1.281) | Yes — | Yes — which versions a session started with | Unobservable | Code-diff via |
Codex | Not supported yet | — | — | — |
Agents & integration
The individual pilot supports Claude Code only, with session-start briefings, MCP tools, local decision packs, and optional completion checks. Explicit CLI/MCP operations remain available if hooks are unavailable. No model calls run after every edit.
The ledger remains vendor-neutral and the existing team integrations are retained. Codex and other individual-onboarding adapters are deferred.
CLI Commands
Use npx lockstep-cli <command> without installing a global binary, or lockstep <command> if installed globally.
Command | What it does |
| Preview inputs, connect, scan the repo, review decisions, and configure Claude |
| Proceed past setup confirmation and skip documentation import |
| Approve setup and document upload; optionally narrow candidates with comma-separated paths |
| Authenticate with GitHub and optionally save your server |
| Configure Claude independently of onboarding |
| Create or join the intended project |
| Preview/apply a dependency manifest, or sync the existing manifest |
| Refresh the local decision pack or check its freshness |
| Check tracked changes against relevant accepted decisions |
| Enable or revoke automatic hosted diff checks |
| Print a copyable project decision brief |
| Invite a colleague to the connected project |
| Inspect configuration, connection, and verification status |
| Remove Lockstep-managed Claude entries while retaining ledger history |
| Opt this checkout in to your organization's managed skills (Standards & Skills) |
| Sync or resolve managed org skills; sync also runs at every session start |
Project Structure
packages/core/ # Fastify API + PostgreSQL (Drizzle ORM), RLS-isolated, append-only ledger
packages/cli/ # lockstep-cli — onboarding, continuity, advisory checks, MCP server
packages/web/ # Next.js dashboard — briefs, review, decisions, features, team workflows
actions/pr-check # GitHub Action — PR-time reconciliation gateLearn more
Deploy · Contributing · Security · Changelog
Built on row-level-security Postgres, an append-only CAS-versioned decision ledger, and vendor-neutral MCP adapters. Self-host with
docker composeor deploy to Railway.
License
Apache 2.0 © 2026 Naman Jain
Available Tools
20 toolsack_decisionA
Acknowledge a decision version. An ack or approve verdict (default ack) moves an open decision to binding. Records your review in the audit trail either way and returns the decision status. Use for a decision proposed by someone else that is awaiting acknowledgement; use propose_decision to create or change one, and decisions to find ids and versions.
Inputs: version (required), decisionId (required), verdict.
ack_inboxA
Mark inbox items as read by id. With no ids, marks every unread item in this session's inbox. Returns the acknowledged count. This only clears inbox items; to respond to a decision use ack_decision, and to reply to a question use answer.
Inputs: itemIds.
answerA
Answer a question from the project's inbox by its questionId. Records the response as an answer, marks the question answered and returns the answer id and status. Use ask to raise a question; answer is only for replying to one. Writes a permanent record; the call does not check that the question is still unanswered, so a second call adds another answer.
Inputs: response (required), questionId (required).
askA
Ask the project a question, optionally tied to a scope. It is delivered to the project's inboxes; urgent flags it. Returns the question id and status. Use for a question that needs a person or another team to reply; try query first, since it searches existing answers without notifying anyone. Replies are recorded with answer.
Inputs: question (required), scope, urgent.
check_decisionsA
Check the working-tree diff against accepted decisions. Returns status skipped unless hosted diff checks are enabled (lockstep checks on). The optional base is the git ref to diff against. Uploads the diff of tracked changes (untracked files are not uploaded) to the Lockstep server and returns the findings: possible contradictions with accepted decisions, each with file, line and the rule. Findings are advisory; use decisions to read the decisions themselves.
Inputs: base.
completeA
Mark a task closed by its taskId. The optional note is accepted but not currently stored. Sets the task to done and closed and returns the status; the call does not check who the assignee is. Use for a task created with delegate.
Inputs: taskId (required), note.
consumersA
List the repos that consume a surface, from the declared-dependency graph. Read-only. Only dependencies declared with register_dependency or found by scanning appear. Use before changing a surface to see who is affected; use whoowns for file owners.
Inputs: surface (required).
decisionsA
List the project's decisions, optionally filtered by scope. Read-only. Returns each decision with its id, scope, status (for example open or binding), version, rule text and review fields. Use query to search by topic instead, and check_decisions to test a diff against decisions.
Inputs: scope.
delegateA
Create a task from a description, with optional refs. The required to value is the assignee's GitHub login; if no member matches, the task is created with no assignee. Returns the task id and run state. Creates an open task and notifies the assignee through their inbox. Use complete to close it later; use ask instead if you only need an answer.
Inputs: to (required), task (required), refs.
get_product_contextA
Return the full product constraints and governed surfaces for a capability, surface or text scope, plus project principles. Constraints are empty when the product layer is off for the project. Read-only. Use before building a feature to learn the product rules for it.
Inputs: scope (required).
inboxA
List this session's unread inbox items: changes, questions, tasks, decisions and conflicts. Does not mark them read; use ack_inbox for that. Use query instead to search the ledger by topic, and decisions to list decisions.
Inputs: no named parameters.
notifyA
Publish a change to the project's change feed so other teams' agents see it. Use for something that already changed or is about to; use ask to pose a question and propose_decision to record a rule. Optionally tied to a surface (for example http:POST /session) with a contract delta. Risk tier owned publishes immediately; shared and contract changes wait for confirmation. Changes with a surface are delivered to repos that declared a dependency on it. Returns the change id, publish state, delivered count and impact (number of consuming repos).
Inputs: summary (required), surface, diffHash, riskTier, +4 more.
propose_decisionA
Propose a decision (rule, architecture or principle) for a scope, with optional rationale, rejected alternatives and review date. Uses optimistic concurrency: baseVersion must equal the decision's current version (0 for a new decision), otherwise the call fails with a conflict. Owner-scoped decisions bind immediately; shared or cross-cutting ones stay open until acknowledged.
Inputs: ruleText (required), scopeRef (required), scopeKind (required), baseVersion (required), +5 more.
queryA
Search the project's decisions, changes and answered questions for a natural-language question. The optional scope boosts matching results in the ranking rather than filtering them. Returns rows; the calling agent writes the answer. Read-only, nothing is sent to anyone; use ask when the ledger has no answer and a teammate should respond.
Inputs: question (required), scope.
refresh_decision_packA
Download the compiled decision pack and rewrite the generated local decision-pack skill in the working directory. Returns the pack hash, file path, whether the file changed and counts. Writes local files. Call when decisions may have changed and the local skill is stale; it does not change any decision on the server and takes no input.
Inputs: no named parameters.
register_dependencyA
Declare that this repo consumes a surface (for example http:GET /orders/:id), so changes to that surface are delivered to this repo. producedRepoId optionally names the producing repo. Repeating the same declaration is harmless. Changes to a declared surface then reach this repo through notify and its inbox. Use consumers to see who depends on a surface.
Inputs: producedSurface (required), producedRepoId.
session_briefingA
Return the continuity briefing for this session: what changed and what is binding, scoped to the current feature context when one is set. Read-only. Call at the start of a session or after being away; use inbox for unread items addressed to you and decisions for the full list.
Inputs: no named parameters.
set_feature_contextA
Set the active capability reference for this session. Writes local state and a feature-context file for the checkout's git remote when one exists. Later notify and propose_decision calls use it unless they pass their own capabilityRef. Call it when starting work on a feature; it changes only local state and never contacts the server.
Inputs: capabilityRef (required).
sync_skillsA
Sync managed organization skills into this checkout. Returns not_enrolled unless the checkout was enrolled with lockstep enroll. Installed or updated skills load from the next session. Writes local files in the checkout. Takes no input; use refresh_decision_pack for decisions instead of skills.
Inputs: no named parameters.
whoownsA
Return the owners of a file path from the repo's current ownership snapshot (CODEOWNERS). Empty when there is no snapshot or no match. Read-only. Use before asking or delegating to find the right person; use consumers for who depends on a surface.
Inputs: path (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 20 tools
Most tools have distinct resource/action targets, and descriptions explicitly cross-reference alternatives such as query vs ask, inbox vs decisions, and refresh_decision_pack vs sync_skills. Some read-oriented tools (session_briefing, inbox, decisions, query) overlap conceptually but remain distinguishable.
Names are mostly lowercase snake_case and readable, but conventions are mixed: some are verb_noun (propose_decision, register_dependency), some are noun-only (inbox, decisions, consumers), and whoowns breaks the underscore pattern. The set is understandable but not predictably uniform.
Twenty tools is heavy for a single MCP server and sits in the borderline 16-25 range. The broad collaboration domain justifies many capabilities, but the surface feels near the upper bound for easy agent selection.
Core areas such as decisions, inbox, questions, changes, dependencies, and context are covered, but lifecycle gaps remain: tasks only support delegate and complete without list/get/update, and changes or dependencies lack direct listing/removal operations. These are notable gaps that could force workarounds.
Maintenance
Related MCP Connectors
Team memory for AI coding agents and code reviews, reviewed by humans and served over MCP.
shared AI-context layer for teams — persistent memory your agents search and update over MCP
Give your AI agent persistent, governed memory for every project. At task start it recalls the approved decisions, conventions, risks and architecture (semantic search, ranked by importance); at close it proposes what was learned as typed memories that you review and approve — governance, not a notes dump. Agents propose, humans govern: edits go back to pending and deletion is human-only by design. Connect Claude Code, Cursor, Claude Desktop or any MCP client in two minutes with just your API key — hosted (nothing to install) or locally via `uvx solucortex-mcp`. Built by SoluAI and dogfooded daily: SoluCortex is developed using its own living memory.
Shared memory for teams: every AI agent works from your company's knowledge, decisions and history.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenancePersistent decision memory and contradiction detection for AI coding agents. Enforces architectural consistency across sessions — the agent cannot code until it loads prior decisions. Human resolves conflicts on a dashboard or in chat.1MIT
- AlicenseAqualityCmaintenanceShared, code-grounded memory for developers and their coding agents. Capture a learning once and the whole team plus every agent recalls it; memory is grounded in your code and stored as git-tracked JSON reviewed in PRs, with citations validated on write and stale memory withheld from recall. Works with any MCP client.1141GPL 3.0

mem0-mcpofficial
AlicenseAqualityDmaintenanceSelf-hosted Mem0 MCP server integrating Qdrant, Neo4j, and Ollama for semantic memory search, graph entity relationships, and memory management via OpenMemory API.64MIT- AlicenseAqualityBmaintenanceSelf-hosted decision memory for AI coding agents. Captures decisions with the alternatives you rejected, and warns before an agent re-proposes a rejected approach.490Apache 2.0