Stele – A Knowledge Graph That Keeps Agent Projects in Order

TL;DR

TL;DR: Stele is a hosted knowledge graph that gives every AI coding agent in your project the same shared memory—decisions, risks, tasks, and provenance—surfaced automatically at the start of each session.

Source and Accuracy Notes

• Project page: stele-ai.dev — verified product site
• HN launch thread: news.ycombinator.com/item?id=49010384
• Pricing page: stele-ai.dev/pricing — verified pricing tiers
• License: proprietary SaaS (no open-source license; SQLite self-hosting planned for Team tier)
• Source last checked: 2026-08-04 (website content)

What Is Stele?

Every developer who has handed a project to an AI coding agent has hit the same wall: the agent starts cold. It does not know that you already tried approach X in March and it regressed production. It does not know that TASK-91 exists for a reason. It re-makes decisions the team already made.

Stele is a hosted knowledge graph that lives alongside your project. Agents read it at the start of every session and write back to it as they work. When a new session begins—whether you are in Claude Code, Cursor, or Codex—Stele pulls in the relevant decisions, active tasks, and hard-won learnings before the first prompt lands.

The key claim is not just storage—it is self-maintenance. Stele tracks when a decision was reversed, when a risk was resolved, and when a fact has drifted from the live code. Entries that are no longer accurate do not disappear; they are retired and replaced, so the record tells the full story.

How It Works

Setup

One line installs the stele CLI:

npm install -g @stele/cli

Sign in with your invite email, then run this once inside your agent:

/stele:start

That is the entire setup. From then on, your agent reads the project graph at session start and files new learnings at the end.

The Knowledge Graph Structure

Stele builds a graph of four node types:

• Decisions — architectural choices, why they were made, who approved them
• Risks — known failure modes, their provenance, and resolution status
• Tasks — claimed work queue, visible to the whole team and all agents
• Facts — code-adjacent knowledge that agents can re-verify against the live codebase

Every node carries provenance: which task created it, who approved it, and when it was last verified. Agents can trace any decision back to the work that produced it.

Cross-Agent Compatibility

Stele works with the agents you already use. The landing page lists first-class support for:

• Claude Code
• Cursor
• Codex
• Antigravity
• GitHub Copilot
• OpenCode
• Grok Build
• Kimi Code CLI
• Pi

Any MCP-compatible client can also connect via the hosted endpoint. All agents read and write the same shared graph, so context moves with the project regardless of which tool you open it in.

Pricing

Stele is free during beta and uses invite-based access. After that, three tiers:

| Plan | Price | Highlights | |------|-------|------------| | Free | $0 / forever | 1 private project, 250 assistant turns/mo, unlimited public projects | | Pro | $12 / month | Unlimited private projects, 1,500 turns/mo, hosted MCP, monthly knowledge review | | Team | $20 / user / month | Unlimited members and projects, 5,000 pooled turns/mo, roles + audit log, biweekly review |

Search and retrieval are unlimited on every plan. Only the assistant turns (which run a frontier chat model) are metered. When you hit your limit, the assistant pauses and tells you rather than cutting you off mid-conversation.

Self-Maintenance: The Core Differentiator

The FAQ poses a direct question: why not just use CLAUDE.md or a file in the repo? The answer Stele makes is accuracy over time.

A file has no opinion about what is 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.

Stele addresses this in three ways:

Drift detection — facts that have moved away from the live code get flagged for human review. Nothing silently goes stale.

Retired risks — a resolved risk removes itself from active consideration but stays in the record, still explaining itself.

Agent re-verification — agents can re-check stored facts against the current codebase as part of their work, keeping the graph anchored to reality.

Practical Evaluation Checklist

• Does it work with your existing agent (Claude Code, Cursor, etc.)?
• Does the knowledge graph surface relevant context before agents act, or only when prompted?
• Can agents write back to the graph mid-session, or only read?
• How does Stele handle a decision that was partially reversed (partial history preserved)?
• On the Free plan, is 250 assistant turns per month sufficient for your workflow?
• Does the invite-only model block your team from trying it?

Security Notes

• Project data is private per project — not used for model training without explicit consent
• Source code stays on your machine; Stele receives graph nodes, not source files
• Self-hosting available from Team tier upward (SAML/OIDC SSO as an add-on)
• Export or delete your entire graph at any time

FAQ

Q: Is Stele open source? A: No—it is proprietary SaaS. A SQLite-backed self-hosted version is planned for the Team tier. The CLI, plugin, and SDK are free on every plan.

Q: How is this different from CLAUDE.md or a repo file? A: A file cannot detect when it has gone wrong. Stele actively flags drifted facts, retires resolved risks, and lets agents re-verify stored claims against the live code. A note written once is still there whether it is true or not; Stele keeps checking.

Q: Which agents can write to the graph? A: All listed agents (Claude Code, Cursor, Codex, and others) read and write. Any MCP-compatible client can also connect and participate.

Q: What happens if I hit my assistant turn limit? A: The assistant pauses and tells you rather than cutting off mid-conversation. Turns resume on the next billing period or when you upgrade.

Q: Does Stele work outside a coding agent? A: Yes. Non-coding agents like ChatGPT can connect over MCP and access the same project context from any device, without cloning the repo.

Q: Is my code or data used to train models? A: No. Project data is private, never sold, and never used for training without your explicit permission.

Conclusion

Stele addresses the handoff problem that every multi-agent project eventually hits: when the agent you were using yesterday did not leave enough signal for the agent you open today. By keeping a self-maintaining graph of what the project has decided and learned, it gives every new session a meaningful starting point instead of a clean slate.

The invite-only model means access is limited in the short term, but the Free tier is generous enough to evaluate a real project before deciding whether to pay. If you regularly switch between agents or work with a team of humans and agents, Stele is worth watching—and trying if you can get an invite.