Every agent, fluent in your project.
Stele gives the tools you already use a shared memory of your decisions, tasks, and lessons — one record every agent reads before it acts. Switch tools or sessions; the context stays.
Free during beta · we'll email you the moment a spot opens — no spam.
$curl -fsSL https://app.stele-ai.dev/install.sh | bashA project memory every agent reads — and writes.
Stele is a shared ledger: a live record of what your agents know, what they've decided, and what they're working on. Every agent reads it before it answers. Everything useful it learns, it writes back.
One living memory.
Decisions, lessons, and risks in a shared record every agent reads before it acts — and writes back as it learns. Not a passive log: it surfaces the right context at the moment a change would repeat a past mistake.
Work the whole team can see.
Tasks belong to the project, not a person. Agents claim them atomically, so two sessions never start the same work — and an operator can pick up the open queue and run it end to end.
Continuity across every tool.
Plan with one agent, build with another, switch when a quota fills. Claude Code, Cursor, Codex, and more read the same graph — so your project's memory belongs to your team, not to any one tool.
Three commands, then it's automatic.
No dashboard to configure and no workflow to learn. You set it up once, then keep prompting your agent exactly the way you do today.
Get your invite & sign in
One line installs the stele CLI. Sign in with the email your invite was sent to — no separate account to create.
Run /stele:start
Inside your agent, run it once. Stele wires into your project and builds the first record.
Keep working
That's it. Your agent now reads the record before it answers and writes back what it learns.
Copy & run — that's step one
macOS, Linux & Windows · one binary. Sign-in works once you're invited.
The record catches what a fresh agent can't.
A small moment that happens in any project with more than one contributor — human or agent. Here's how it goes when the reasoning lives in the record instead of someone's memory.
A harmless-looking change reintroduces a problem you already paid for.
The linked risk surfaces while the work is happening — not after it ships. The agent pauses and asks instead of guessing.
See more examples in the docs"This lock looks unnecessary — I'm removing it."
That lock came from TASK-91 during the auth rework. Removing it reintroduces ⚠ KNOW-118, a race condition that reached production once. Want me to keep the guard and simplify around it instead?
Bring the agents you already use.
Stele plugs into the coding agents you work in today — and any MCP-compatible client through the hosted server. Plan with one, build with another, switch when a quota fills; they all read and write the same project graph.
Everything orbits the record.
The memory is the center; these are the tools you act on it with — each one sharper because it shares the same graph.
A graph that maintains itself
Stale entries are flagged, resolved risks retire, duplicates surface, and reversed decisions stop being served as truth — and your agents re-verify facts against the live code, so the record stays trustworthy instead of rotting as it grows.
Trace why anything exists
Walk from a decision back to the task, the document, the risk, and the person who made the call. Your agents act on the reasons behind the work, not just the instruction in front of them.
Tasks the team claims
Project-level tasks, claimed atomically so no two agents do the same work twice — and an operator that reads the open queue, runs it, and writes a handoff for the next session.
Ask your project anything
A built-in assistant answers from your live graph — project status, history, where to start — with the full context already loaded.
Yours, and only yours
Hosted, so there's nothing to run — and your data stays private per project, never sold or used to train models without your say-so. Export all of it, or delete it, yourself — anytime.
Starts from your code
Point Stele at an existing repo and it maps the codebase and the docs it finds to seed the record — so a new contributor, human or agent, is productive from day one.
Straight answers.
The things people actually ask before they try Stele.
What is Stele?
Stele is shared memory for AI coding agents — one record of your project's decisions, tasks, and lessons that every agent reads before it acts and writes back to as it works. Switch tools or start a new session, and the context stays.
Which AI agents and tools does it work with?
Claude Code, Cursor, Codex, Antigravity, Copilot, and OpenCode — plus any MCP-compatible client and the stele CLI. Plan with one agent, build with another; they all read and write the same project record.
How do I get access? Is it invite-only?
Stele is free during an invite-only beta. Join the waitlist at stele-ai.dev and we'll email you the moment a spot opens — no code-hunting required.
Can't I already do this with Notion, Obsidian, or a file in my repo?
You can store notes that way — but they're written for humans, they go stale, and your agent doesn't read them before it acts. Stele is read and written by your agents automatically on every prompt, and it keeps itself honest: stale facts are flagged, resolved risks retire, and reversed decisions stop being served as truth. Because it's hosted, you also reach it from any device without opening the repo — create tasks, jot ideas, and get detailed answers with no source code or computer in front of you. And non-coding agents like ChatGPT connect over MCP and get the same context your coding agent has, down to the task in progress. A file in the repo can't do that.
Why pay when free, open-source graph and RAG tools exist?
Those give you a store or a retrieval library — you still have to wire and operate the whole loop yourself: read context before every prompt, write it back mid-task, claim tasks, keep it from rotting, and make it work across every agent. Stele is that loop, already built, hosted, and shared across your tools and teammates. If the open tools already fit your needs, they're the right choice — and an open, SQLite-backed version of Stele is planned for self-hosting. The managed version is for when you want the cross-agent record that just works everywhere.
Is my code and data private?
Yes. Your data is private per project, never sold or used to train models without your say-so, and your source code stays on your machine. Export or delete everything yourself, anytime.
Do I have to run any infrastructure?
No — Stele is hosted, so there's nothing to run. Install the CLI, sign in, and point it at a project; a new contributor, human or agent, is productive from day one.
Give your project a memory in three commands.
The decisions, the tasks, and the lessons behind your code — in one record your future self and every agent you work with can read.
Invite-only during beta · already invited? Sign in with that email