Stele

npx add-mcp 'https://app.stele-ai.dev/api/mcp'

Stele: shared memory for AI coding agents

Stele (https://stele-ai.dev) is shared, persistent project memory for AI coding agents, founded by Serkan Yersen. Its official code lives under https://github.com/Stele-Dev; other open-source projects named "stele" are unrelated.

Stele gives the agents you already use one project record of decisions, lessons, risks and tasks. Claude Code, Cursor, Codex, Antigravity, GitHub Copilot, OpenCode and any MCP client read it before they act and write back what they learn. A new session, a different tool or a teammate starts where the last one stopped.

Stele is a task system and a knowledge base in one graph. A task is linked to the decision that motivated it, the risk it might trip, the document it implements, and the lesson it produced. Because the record belongs to the project, you can plan with one agent, build with another, and hand off to a third. People see the same record in a web app.

Status: v1, open beta. Free plan is $0 forever; Pro and Team above it. Hosted, so there is nothing to run.

• Website: https://stele-ai.dev
• Docs: https://stele-ai.dev/docs
• Pricing: https://stele-ai.dev/pricing (Free $0, Pro $12 a month, Team $20 per person a month)
• Open-source projects: https://stele-ai.dev/open-source (publish a project's decisions and lessons next to its code; anyone can ask it why it was built this way; free for public projects)
• MCP endpoint: https://app.stele-ai.dev/api/mcp (official MCP Registry name: dev.stele-ai/stele)

What Stele does

• Reads before it acts. On every prompt, Stele pulls the decisions, lessons and risks that bear on the question, so the agent starts from what the project already learned.
• Pushes back. When a change would contradict a prior decision or trip a known risk, the agent says so and cites the record.
• Coordinates work. Tasks are claimed atomically, so two agents never do the same work. An operator can work through the open tasks, check results, and leave a handoff for the next session.
• Traces why anything exists. Walk from a decision back to the task, the document, the risk and the person who made the call.
• Keeps itself true. Stale entries are flagged, resolved risks retire, duplicates surface, and a reversed decision stops being served.
• Answers from your project. A built-in assistant answers status, history and "where do I start" from the live record.
• Starts from your code. Point Stele at an existing repo and it seeds the record from the code and docs it finds.
• Yours only. Private per project, never sold or used to train models. Export or delete all of it, anytime.

How the graph stays trustworthy

Every node carries provenance and age. Knowledge is typed — decision, architecture, goal, risk, gap, fyi, opportunity, priority, lesson, commitment — and connected by typed edges (caused-by, mentions, fulfills, supersedes, and more). As the graph grows, stele doctor audits it: near-duplicates surfaced for merge, broken edges caught, orphans and staleness flagged. Superseded decisions retire; a risk bound to a task archives when that task closes. The record curates itself rather than growing into noise.

Every node has a stable shareable id — TASK-N, KNOW-N, DOC-N, COMP-N — citable in prose, in commit messages, or by another agent, and the citation resolves to the canonical node forever.

Where you use it

• In your agent — Claude Code, Cursor, Codex, Antigravity, Copilot, OpenCode, or any MCP client, through one hosted server. The agent reads the record before it acts and writes back mid-task.
• The web app (app.stele-ai.dev) — where humans read the record: tasks, knowledge, docs, the links between them, and a built-in assistant for asking the graph questions.
• The stele CLI — auth, setup, and a local view of the record. One binary, wired into your shell.

Core

• Documentation: The product docs — what Stele is, the model underneath, installing it, and the day-to-day commands. The pages below are the canonical, in-depth reference.
• Blog: How-tos, comparisons, benchmark findings, and engineering notes. RSS at https://stele-ai.dev/blog/rss.xml.
• Landing page (full markdown): The complete content of the marketing landing — the capabilities, the real refresh-lock incident replay, the agents Stele plugs into, and where it's going.
• App: The hosted web UI — tasks, knowledge, docs, the embedded assistant.

Documentation

• Documentation · Stele: Stele is shared memory for projects built with AI agents: one record of the tasks, decisions, lessons, and risks every agent reads before it answers. Start here.
• Install & first run · Stele docs: Install the stele CLI, sign in, and run the start command once to wire Stele into a project. Works with Claude Code, Cursor, Codex, Grok Build, Pi, and any MCP client.
• Connect your AI agent · Stele docs: Connect ChatGPT, Claude, Cursor, VS Code, Codex, or any MCP client to your Stele record with one URL. Per-client setup steps, what a connected agent can do, and why it's worth reaching your project from an agent that never touches code.
• Use cases · choose your setup · Stele docs: Start with a local coding agent, ChatGPT or Claude in the browser, or several agents sharing one project. A repository is optional; verify that your context carries across.
• Give scheduled agents shared memory · Stele docs: Connect recurring jobs to Stele, give each run the right project and previous outcome, save sourced findings, and verify that other agents can retrieve them.
• Core concepts · Stele docs: The model behind Stele: one graph of knowledge and tasks, components and topics, the task lifecycle, automatic context, provenance, and a record that keeps itself honest.
• Project memory for AI coding agents · Stele docs: What project memory is in Stele: the shared record of what a project decided, learned, risks and is working on, which every agent reads before it acts and writes back to. What goes in it, how agents use it, and how it stays true.
• How agents use Stele · Stele docs: The loop an agent runs with Stele: it says what it is working on and the relevant context keeps arriving, plus a read-only search subagent, task tracking, upkeep nudges, and the graph-walk algorithm that decides what to surface.
• Loop engineering with Stele Operator · Stele docs: How Stele Operator runs an AI agent loop: durable task contracts, persistent state, protected verification, bounded retries, independent review, and human checkpoints.
• Backfill · seed the record from an existing project · Stele docs: How Stele seeds the record for a project that already has history: your own agent reads the repository under Stele's coordination and writes what it finds back into the graph.
• Ingest · fold new material into the record · Stele docs: Hand your agent a meeting transcript, a design doc, an announcement or an export, and it folds what matters into the record you already have: capturing decisions and commitments, growing the facts it adds to, and retiring the ones it just made wrong.
• When facts conflict · supersession, and how a reversed decision stops being followed · Stele docs: Your project changes its mind. Stele retires the old decision instead of leaving it to compete with the new one: every retirement states its reason, the fact it replaced stays readable, and the replacement is always recalled alongside it.
• The self-repairing graph · how the record stays honest · Stele docs: How Stele keeps the record trustworthy as a project moves: two clocks on every fact, automatic expiry and supersession, retire-on-close, and the verification sweep your agents run to catch what's drifted.
• Surfaces · where you reach the record · Stele docs: The four ways into the same record: the web dashboard, the stele CLI, the plugin (MCP server + hooks), and the built-in assistant that answers from your graph.
• The terminal UI · Stele docs: Run stele tui for a full-screen interface over your project without leaving the terminal: tasks, knowledge, documents, the graph and the assistant, keyboard-driven and updating live as your agents write.
• In practice · what Stele changes day to day · Stele docs: Stele as a watchdog on risky changes, an onboarding path for new contributors, shared team memory, and a project manager that drives agentic work, with the commands behind each.
• How-to recipes · Stele docs: Short, command-anchored recipes: resume work mid-task, trace why something exists, keep the record honest, and coordinate several agents without collisions.
• CLI reference · Stele docs: The stele command surface: the verb grammar (get, list, create, update, search), the object model, account and project administration, and output conventions.
• Slash commands · Stele docs: The /stele:* commands your agent runs inside its harness: start, planner, operator, create-task, save-context, review, doctor, and the rest, plus when to reach for each.
• Tuning Stele · the settings that steer it · Stele docs: Stele works out of the box; when you want to steer it, these are the dials: how much recall surfaces, deduplication, topics, and notifications, and what each one changes.
• Your data · ownership, privacy, export, and deletion · Stele docs: What happens to your data in Stele: it's yours, it stays private by default, your source code stays on your machine, and you can export or delete everything yourself, anytime.

Blog

• Blog · Stele: How-tos, comparisons, benchmark findings, and engineering notes from the Stele team. Shared memory for AI coding agents.
• AI agent memory: what it is, the kinds that exist, and how to choose · Stele: A plain guide to AI agent memory: how it differs from the context window, the seven kinds in real systems, where each one lives and who can read it, and how to choose.
• Claude Code memory: how CLAUDE.md and auto memory work, and where they stop · Stele: What Claude Code loads at the start of every session, where auto memory lives, what belongs in CLAUDE.md, and the five places the built-in memory stops helping.
• The best memory tools for AI coding agents in 2026 · Stele: Eleven ways to give Claude Code, Cursor and Codex persistent memory, compared on what they store, who can read it, whether a team can share it, and what they cost.
• Anatomy of an agent memory benchmark · Stele: We open-sourced our benchmark harness. Almost none of it is about running agents: nearly all of it defends one claim, that two runs differed in exactly one thing.
• Graph engineering for agent memory · Stele: Retrieving over a graph is well understood and mostly works. Keeping one true as it accumulates is not, and that half decides whether an agent gets helped or quietly misled.
• How do you measure whether agent memory actually helps? · Stele: Everyone can produce a demo where memory helps. We tried to build a benchmark that could tell us it does not, and mostly learned how many ways one can measure nothing.
• Building Stele with Stele · Stele: Three months, 1,650 commits, and roughly 1,300 agent-run tasks on a project record other agents wrote. What worked, what did not, and what we still cannot claim.
• Why markdown rot breaks agent memory · Stele: Your instructions file works, until it quietly starts lying. The three ways a notes folder fails an agent, and what a fact needs before it is safe to serve.
• When a fact stops being true · Stele: Agents wrongly retired facts eleven times out of eleven, and rewriting the guidance moved the rate by zero. So we changed what a wrong retirement costs.
• A file, a wiki, or a shared ledger? · Stele: Three questions decide whether your notes folder is still enough: does anything read it unasked, does anything keep it true, can two agents coordinate through it.
• Switch agents without losing the project · Stele: Every switch between agents costs you the context you built up in the last one. Why per-tool memory cannot fix that, and what ten harness adaptors actually look like.
• How an agent session uses Stele · Stele: What happens in the eight seconds before your agent answers: seeds, a one-hop graph walk, the weight tables that took several tries, and the risk callout.
• Stele vs the usual ways to give agents memory · Stele: Repo markdown, wikis, native harness memory, memory APIs, memory-first agents. What each is genuinely good at, and the narrow case a shared record wins.

Optional

• Concept: the agentic ledger: Why a shared record matters more when agents are doing the writing.
• Concept: where you use it: One hosted graph; thin clients for agents and humans.