Skip to main content
Glama

aionai

A shared working-state layer for your AI coding tools. Claude, Cursor, and other MCP clients read and write one small notebook, so they stay on the same page — and you stop being the copy-paste bus between them.

PyPI CI Python License

Add aionai to Cursor

One-click install for Cursor (it configures uvx aionai). After it's added, set AIONAI_SOURCE=cursor in the server's env. If Cursor can't find uvx, see Troubleshooting; or set it up manually via Connect your tools.


The problem

You use more than one AI assistant on a project. They don't know what each other did: you tell Claude a decision, switch to Cursor, and Cursor has no idea. You end up re-explaining and copy-pasting context by hand.

Related MCP server: memmd-mcp

What aionai does

aionai is a tiny local MCP server that keeps a shared, persistent notebook every tool can read and write. It does three jobs:

  • Remember — decisions, changes, questions, and notes, organized by project.

  • Track — a lightweight roadmap/to-do list with progress rollup.

  • Hand off — post a task to another tool's inbox (with an optional "doorbell").

It does not replace your repo, docs, or git — those stay the source of truth. aionai just holds the live working state and hands each tool the slice it needs.

Install

Most portable — works on Windows, macOS, and Linux, and puts the aionai command where GUI apps (Cursor, Claude Desktop) can find it:

pipx install aionai

Already use uv? Skip the install entirely:

uvx aionai --help

Requires Python 3.10+. If a client later reports the launcher (aionai / uvx) "not recognized", see Troubleshooting.

Connect your tools

Point each client at the aionai command. Give each client a distinct AIONAI_SOURCE (so handoffs route correctly) and set AIONAI_SEGMENT to your project name.

Claude Code

claude mcp add aionai --env AIONAI_SOURCE=claude-code --env AIONAI_SEGMENT=myproject -- aionai
# or with uv:  claude mcp add aionai --env AIONAI_SOURCE=claude-code -- uvx aionai

Cursor — .cursor/mcp.json:

{
  "mcpServers": {
    "aionai": { "command": "aionai", "env": { "AIONAI_SOURCE": "cursor", "AIONAI_SEGMENT": "myproject" } }
  }
}

Claude Desktop — Settings → Developer → Edit Config:

{
  "mcpServers": {
    "aionai": { "command": "aionai", "env": { "AIONAI_SOURCE": "claude-desktop", "AIONAI_SEGMENT": "myproject" } }
  }
}

Restart the client after editing its config — MCP servers are launched (and their env read) when the client connects.

Use it

Add this to each tool's rules (CLAUDE.md, Cursor rules) so they do it reflexively:

Before working, call context_pull(segment="myproject") and treat the result as the current truth. As you work, context_log(...) your decisions/changes/questions/tasks. When something is settled, context_resolve(id).

That's the whole loop: pull first, write back. Now open Cursor and it already knows what you and Claude decided — no paste.

Segments

State is organized by a dotted segment path whose first element is the project:

myproject                     # the whole project
myproject/backend             # a layer
myproject/backend/auth        # a workstream

Pulling a parent includes all descendants. That one mechanism keeps an always-on space from turning into an undifferentiated blob.

The tools

tool

purpose

context_pull(segment)

current working state + your inbox

context_log(segment, type, content, refs)

append a decision/change/question/task/note

context_resolve(id)

close a question or task

context_search(query, segment)

full-text recall over history

context_verify(segment)

check change entries against git (merged vs. bare claim)

context_handoff(segment, content, to)

post a handoff to another tool's inbox

roadmap_add_node / roadmap_update / roadmap_block

build & manage the roadmap

roadmap_view / roadmap_progress

see the tree / how far along

constraints_for_task(segment)

decisions + open questions that constrain a task

project_lookup(query, project)

reuse an approach from another project

They also surface as slash commands (/mcp__aionai__pull, …log, …resolve, …search, …handoff) in clients that support MCP prompts.

Optional extras

  • Auto-ingest commits — copy hooks/post-commit into a repo's .git/hooks/ (set AIONAI_SEGMENT) and every commit logs itself as a change.

  • Doorbell — set AIONAI_DELIVERY=1 in a sender's env and a context_handoff to Cursor also summons Cursor via its deeplink (you confirm before it runs). Without it, handoffs are inbox-only. Only cursor has a verified deeplink today.

How it works

One SQLite database, one append-only table. Every decision, task, handoff, and roadmap node is a row tagged with a segment and a type. History is free because nothing is overwritten. Full-text search uses FTS5 with a LIKE fallback. The MCP tools are thin wrappers over a plain-Python storage layer (src/aionai/store.py).

Troubleshooting

A client reports 'uvx' / 'aionai' is not recognized (or the server errors on start). The client can't find the launcher on its PATH — common for GUI apps (Cursor, Claude Desktop) on Windows and macOS, which don't always inherit your shell's PATH. Fixes, best first:

  1. Use pipx: pipx install aionai, then set "command": "aionai". pipx puts the command where GUI apps usually find it.

  2. Point at the full path of the launcher. Find it with where uvx (Windows) or which uvx (macOS/Linux), then use it verbatim, e.g.:

    "aionai": { "command": "C:/Users/you/AppData/Roaming/Python/Python3xx/Scripts/uvx.exe",
                "args": ["aionai"], "env": { "AIONAI_SOURCE": "cursor" } }
  3. Skip the launcher — run via your Python directly (after pip install aionai):

    "aionai": { "command": "python", "args": ["-m", "aionai.cli"] }

Then restart the client so it re-reads the config.

Configuration

var

default

purpose

AIONAI_DB

~/.aionai/aionai.db

database path (share explicitly if clients don't hit the default)

AIONAI_SOURCE

agent

who is writing (cursor / claude-code / claude-desktop); routes the inbox

AIONAI_SEGMENT

project

default project segment

AIONAI_DELIVERY

(unset)

1 enables the doorbell in the sender

Development

git clone https://github.com/imsm/aionai && cd aionai
pip install -e ".[dev]"
pytest
ruff check .

License

Apache-2.0 © Ismail Saleh.

Available Tools

13 tools
constraints_for_taskA

Before implementing a task, get every decision and open question that may CONSTRAIN it — from the task's segment, its ancestors, and its descendants (not recency-limited). Surface any conflict with your plan BEFORE coding.

Inputs: segment (required). Returns: result

context_handoffA

Post a handoff to another tool's inbox (to = cursor | claude-code | claude-desktop). It lands in the target's inbox and stays PENDING until the receiver resolves it. If AION_DELIVERY is enabled and the target has a verified deeplink (today: cursor), a doorbell also summons that tool with a fixed nudge — the URL never carries your content. Returns the entry id and delivery outcome.

Inputs: to (required), content (required), segment (required), refs, +1 more. Returns: result

context_logA

Append an entry to the shared working state so other tools see it: type = decision | change | question | task | note. refs is optional JSON (e.g. {"files": ["..."], "commit": "abc123"}). Returns the new entry id.

Store WHAT/WHY (facts, decisions, intent), not HOW (procedure). A change is "done" only when merged in git — include refs.commit/refs.pr; without a ref it is recorded as a CLAIM (verify with context_verify).

Inputs: type (required), content (required), segment (required), refs. Returns: result

context_pullA

Pull the current shared working state for a project segment (and its sub-segments). Call this FIRST, before doing anything on the project: it returns the open tasks, open questions, recent decisions/changes/notes, and your inbox of handoffs. Treat it as the current truth about where the work stands.

segment is a dotted path, e.g. "myproject" or "myproject/backend/auth"; a parent pulls all descendants. Treat status entries ("fixed"/"done") as CLAIMS to verify against git (see context_verify), not facts.

Inputs: segment. Returns: result

context_resolveC

Mark an open question or task resolved so it stops surfacing in context_pull.

Inputs: entry_id (required). Returns: result

context_verifyA

Completion integrity: list 'change' entries and classify each against GIT (the ground truth) — 'merged', 'present-unmerged', 'missing', or a bare 'CLAIM (no git ref)'. A tool logging "fixed" is NOT done; done = merged in git. Checks commits in the repo the server runs in.

Inputs: segment. Returns: result

project_lookupA

Reuse an approach from ANOTHER project: search that project's history for a topic and adapt the matching decisions/notes instead of starting from scratch. FTS5 does not stem — add a prefix wildcard (auth*) if a bare term is too narrow.

Inputs: query (required), project (required). Returns: result

roadmap_add_nodeA

Add a node to the roadmap tree. kind = project | segment | phase | epic | task. parent_id nests under another node (0 = top-level); a child inherits its parent's segment unless set. priority is 1..5 (1 = highest; 0 = none). Returns the id.

Inputs: kind (required), title (required), segment, priority, +1 more. Returns: result

roadmap_blockA

Record a DEPENDENCY edge: node blocked_id is blocked by blocked_by_id. Use this for real dependencies instead of overloading parent_id (parent_id = decomposition). Surfaced in roadmap_view as a node's blocked_by.

Inputs: blocked_id (required), blocked_by_id (required). Returns: result

roadmap_progressA

Progress summary: per top-level segment and overall, how many leaf work nodes are done vs total, with percentages.

Inputs: no named parameters. Returns: result

roadmap_updateA

Update a roadmap node: set priority (1..5), reparent (parent_id), or set status ('open'/'resolved'). Pass only what you want to change (0/empty = leave as is). Resolving a task/epic is what makes progress roll up.

Inputs: entry_id (required), status, priority, parent_id. Returns: result

roadmap_viewA

Show the hierarchical roadmap (project > segment > phase > epic > task) with done/total rollup per node, sorted by priority. Optionally scope to a segment.

Inputs: segment. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 13 tools

    Disambiguation4/5

    Tools are grouped into context management and roadmap management, each with distinct purposes. Minor overlap between context_search and project_lookup (both search but in different scopes) prevents a perfect score.

    Naming Consistency5/5

    All 13 tools follow a consistent verb_noun snake_case pattern (e.g., constraints_for_task, context_log, roadmap_view), making tool purposes predictable.

    Tool Count5/5

    With 13 tools covering two sub-domains (context and roadmap), the count is well-scoped. Each tool has a clear role without unnecessary redundancy.

    Completeness4/5

    The surface covers core CRUD operations for roadmap (add, update, view, block, progress) but lacks explicit delete for nodes. Context tools are comprehensive, including search, verify, and cross-project lookup. Minor gap in deletion.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      B
      quality
      Not graded
      maintenance
      A state persistence layer that enables seamless handoffs between different AI coding assistants by maintaining a shared context bus. It provides tools for tracking summaries, next steps, and active files to ensure continuity across development sessions.
      3
      -
    • 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
      Not graded
      quality
      D
      maintenance
      A local-first MCP server and continuity control plane that helps AI coding tools maintain project state, tasks, and context across sessions, models, and interruptions, with features like session tracking, token-efficient context assembly, and code understanding via Code Atlas.
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      Shared memory and orchestration for coding agents, enabling persistent knowledge, multi-agent coordination, and a canonical workflow across MCP-compatible AI clients.
      53 npm
      83
      -