Every agent, fluent in your project.
Stele keeps your project's decisions, tasks, and lessons in one shared memory. Claude Code, Cursor, Codex and your other agents read it before they act, so switching tools or sessions doesn't reset what the project knows.
Free forever on the Free plan · no credit card. Works with the agent you already use.
$curl -fsSL https://app.stele-ai.dev/install.sh | bash$ scroll to continue
Same request. Flip the switch.
Only one of these agents knows this was tried last spring and rolled back.
❯We need to add a captcha check on the checkout page, noticing that people are sending bots on new releases.
UserPromptSubmit says: stele recalled 6 memories
The recall points at a prior attempt here. Reading it before I plan anything.
Called stele 5 times, read 2 files
KNOW-142: a captcha on checkout shipped last spring and was reverted after two weeks. Completed orders fell 5%. Same page, same change.
The bot traffic is real, though it spikes on release days and is quiet the rest of the time. A gate armed only during a release window would avoid repeating that.
This was tried and reverted. How do you want to proceed?
- Arm it during release windows onlyScope the challenge to when the bots show up and leave the steady-state flow alone.
- Ship it anyway, across all checkoutsReasonable if the bot damage now outweighs the 5% measured last spring.
- Show me the reverted attemptRead the recorded lesson and what shipped alongside it first.
- Type something.
With the record on, the agent opens by reading it, finds the reverted attempt, and asks before repeating it.
A worked example. The recall line is exactly what Stele prints in a session.
Everything they write lands somewhere you can read.
What was decided, what is in flight, and what already went wrong, with the links between them intact.
A project memory every agent reads, and writes.
A hosted graph your agents reach over MCP. It holds what the project knows, what it has decided, and what it is working on. Every session starts by pulling from it and ends having added to it.
One shared memory.
What the project decided, what it tried, and where it got burned, in one place every agent can write to. When a change would repeat a mistake this project already made, the record surfaces it before the work starts.
Work the whole team can see.
Every task sits in the project's own queue, claimed by whoever picks it up. Two sessions can run at once without landing on the same job, and anyone can take the queue and run it end to end.
Continuity across every tool.
Claude Code, Cursor, Codex and the rest all read and write the same graph. Move between them, or hand the project to a teammate on a different setup, and the context travels with the project.
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.
Create your account
One line installs the stele CLI. Signing in creates your account the first time, so there is nothing to set up first.
Run /stele:start
Inside your agent, run it once. Stele wires into your project and builds the first record.
Keep working
That's it. From here on your agent pulls the record into every session and files what it learns back into it.
macOS, Linux & Windows · one binary. Signing in creates your account.
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 once the reasoning behind the code is written down where an agent can find it.
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.
A memory that keeps itself true.
A note is true the day you write it. Stele is what keeps checking after that: what got reversed, what got resolved, what has drifted away from the code, so your agents are never handed an answer the project moved past months ago.
A graph that maintains itself
Entries that have drifted get flagged for review, resolved risks retire themselves, duplicates surface for merging, and your agents re-verify facts against the live code as they work. Nobody has to schedule a cleanup.
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 see why the work was asked for, which is usually what decides how to do it.
Tasks the team claims
An agent claims a task before it starts, so the next one picks something else. When a session ends mid-flight it leaves a handoff, and whoever comes next reads that before touching anything.
Ask your project anything
Ask the project a question and get an answer from the live graph: where things stand, what changed, where to start, with the full context already loaded.
Yours, and only yours
Your graph is private to your project, never sold and never used to train models without your say-so. Your source code stays on your machine. Export the whole thing, or delete it, whenever you want.
Starts from your code
Point Stele at a repo you already have and it reads the code and whatever docs it finds. The record starts out already knowing your architecture, so the first session is a useful 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 what your project has decided, what it is working on, and what it has learned the hard way. Every agent reads it before it acts and writes back to it 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, OpenCode, Grok Build, Kimi Code CLI, and Pi, plus any MCP-compatible client and the stele CLI. They all read and write the same project record, so it stops mattering which one you happen to be in.
My agent already remembers things. Why add Stele?
Because that memory is yours and Stele's is the project's. Built-in agent memory learns what you do inside one tool, so a teammate on a different agent starts cold, and so do you the moment you switch. A file like CLAUDE.md or AGENTS.md gets further, since it lives in the repo where the whole team can see it, but it holds the house rules you want followed, and it is a document somebody has to keep writing by hand. Stele holds what the project has decided, tried, and learned, and it belongs to the project itself, so it reaches whoever is working and whatever they are working in. A decision one person's agent recorded on Tuesday is there for someone else's agent on Friday. The two do different jobs, so keep the file and add the record.
How do I get access?
Create an account at stele-ai.dev and you're in. The Free plan is $0 forever: unlimited public projects, one private project, and a monthly assistant allowance. Sign in with GitHub, Google, or an email link, and the account is created the first time.
Can't I already do this with Notion, Obsidian, or a file in my repo?
A file has no opinion about what's still true. You reverse a decision, but the old one is still sitting there, and weeks later an agent reads it, believes it, and rebuilds the thing you tore out. Nothing flagged it, because a file can't tell when it has gone wrong. Stele can. A reversed decision is retired: still visible, still explaining itself, but no longer served as truth, and whatever replaced it comes back alongside, carrying the reason for the change. Resolved risks retire themselves, and facts that have drifted get flagged for review. Any of those tools will hold the note perfectly well. The open question is what keeps it true a year later. Full walkthrough at stele-ai.dev/docs/conflicting-facts.
Can I use Stele away from my machine?
Yes. Stele is hosted, so you reach your project 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. Non-coding agents like ChatGPT connect over MCP and get the same context your coding agent has, down to the task in progress.
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 current, 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.
Everything your project has worked out, in one record your future self and every agent you work with can read.
Starts at $0 · already have an account? Sign in