Show HN: Stele – A self-maintaining knowledge graph for AI coding agents

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.

Join the waitlist Have an invite code? Sign in

Invite-only beta · we'll email you the moment a spot opens — no spam.

Already invited? Install the CLI

$curl -fsSL https://app.stele-ai.dev/install.sh | bash

stele · knowledge graphlive

componentdecisionrisktask

open7

TASK-204P1

Rotate the signing key on a schedule

TASK-219P2

Backfill missing component anchors

1/4

in progress2

TASK-198P0

Make account deletion atomic + resumable

3/5op

TASK-211

Guard the complete-summary gate

2/3cc

done41

TASK-191

Atomic claim RPC for tasks

TASK-187

Search RPC over the node graph

2h

KNOW-118Auth lock guards a race that reached prod once

riskreview

1d

KNOW-90Hosted assistant streams via the AI Gateway

architecture

2d

KNOW-76Design system: oklch tokens, one type ramp

decisionverified

4d

KNOW-52Atomic claim keeps two agents off one task

lesson

6d

KNOW-31Expand/contract every schema migration

goal

Explore the live app

Plugs intoClaude CodeCursorCodexAntigravityCopilotOpenCodeGrok BuildKimi Code CLI

What Stele is

A 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.

How it works · about a minute

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.

01

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.

02

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

terminal

installs the stele CLI & signs you in

$curl -fsSL https://app.stele-ai.dev/install.sh | bash

$stele account login

→ signed in ✓

macOS, Linux & Windows · one binary. Sign-in works once you're invited.

In practice

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.

Catch a returning bug

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

your agentstele · on

You

"This lock looks unnecessary — I'm removing it."

Stele

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?

Works with your agents

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.

Claude CodeCursorCodexAntigravityCopilotOpenCodeGrok BuildKimi Code CLIany MCP client

More than memory

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.

Kept honest

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.

Provenance

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.

Coordination

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.

Assistant

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.

Your data

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.

Onboarding

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.

Questions

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, OpenCode, Grok Build, and Kimi Code CLI — 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?

Yes — Stele is invite-only while we open up gradually. 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.

stele · a record that endures

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.

Join the waitlist Explore public projects

Invite-only during beta · already invited? Sign in with that email