Egregore
Shared memory for Claude Code teams—decisions, handoffs, and context persist across sessions and people.
Egregore is a credible bet for one specific shop: a team already living in Claude Code that keeps losing decision rationale between sessions and people. The free local tier costs nothing to trial and needs no API keys, so the honest test is running /handoff and /deep-reflect for two weeks and seeing whether the pattern output earns its place. The $500/month Connected tier is a real jump—compare it against a Notion or Linear subscription combined with manual doc discipline, which is cheaper but gives your agents nothing machine-readable. For teams on Cursor, Copilot, or no CLI assistant at all, this doesn't apply yet.
Verified 9h ago · liveness 79/100 · cite: rightaichoice.com/tools/egregore
- Development teams using Claude Code daily
- AI-native teams running multi-agent human-AI workflows
- Engineering orgs that need decision rationale preserved, not just commits
- Teams comfortable living in the terminal
- Teams not using Claude Code, Codex, or Pi
- Non-technical users who need a GUI to browse knowledge
- Organizations committed to conventional wikis and structured docs
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Egregore if your team writes code in Cursor, VS Code with Copilot, or any assistant outside Claude Code, Codex, and Pi, or if you need a web dashboard that non-engineers can browse.
The $500/month Connected tier is billed per team, not per seat, so the cost is fixed whether you have 3 engineers or 30.
For a solo developer or a small studio, the Free tier costs nothing and runs locally, which beats paying Notion or Linear per seat for docs your agents can't read. Connected at $500/month per team is priced for organizations of roughly 10-50 engineers where a lost decision or slow handoff has real cost—below that headcount, a Notion Plus or Linear subscription plus manual discipline is far cheaper.
In short
Egregore — Shared memory for Claude Code teams—decisions, handoffs, and context persist across sessions and people. Best for Development teams using Claude Code daily, AI-native teams running multi-agent human-AI workflows, Engineering orgs that need decision rationale preserved, not just commits. Free to start; paid plans from $500/mo.
What people actually say about Egregore — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
23 mentions across 2 sources (Hacker News, Lemmy) · researched Jul 3, 2026.
Average across the 2 sources that answered — each source counts once, not each post.
- +Open-source (MIT) and runs locally with no vendor lock-in.
- +Persistent, shared memory across human and AI team members.
- +Slash commands integrate directly into Claude Code workflow.
- +Captures decisions, trade-offs, and open threads for context.
- +Reduces repetitive context-setting for new team members.
- −Very early-stage with limited real-world adoption data.
- −Only works with Claude Code—no support for other AI tools.
- −No official documentation for reliability or scaling guidelines.
- −Community discussions are sparse; hard to gauge common issues.
- −No paid support or enterprise features yet.
- • Requires Claude Code subscription (costs not included)
- • Potential future paid tiers not announced yet
Viability Score
How well maintained and how widely used is Egregore? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- /invite command brings a teammate into shared memory with GitHub org invitation
- /handoff saves decisions, trade-offs, and open threads with underlying reasoning
- /save stages, commits, pushes, and opens a pull request in one command
- /activity shows a daily team board of sessions, handoffs, and quests
- /deep-reflect spawns parallel analysis agents to surface patterns, tensions, and gaps
- Persistent team memory that compounds across sessions
- Multi-agent continuity between human-AI pairs
- Search across everything your team has written
- Works across Claude Code, Codex, and Pi
- Doc ingestion and querying alongside meetings and decisions
- Automated git branching, commit, and PR hygiene
- Temporary shareable links rendering your work
- Permanent branded surfaces for internal and external work (Connected)
- Slack, Teams, and Telegram connections (Connected)
- Local-only operation on free tier with no servers, accounts, or API keys
About Egregore
Egregore is a shared cognition layer for development teams working in Claude Code, Codex, and Pi. It captures the traces of your team's work—decisions, trade-offs, handoffs, and open threads—into persistent memory that both people and AI agents can read and build on. Instead of a wiki nobody updates, Egregore structures knowledge as a living context graph that compounds across sessions. Features arrive as slash commands inside the terminal you're already in: /invite seats a teammate into shared memory and sends the GitHub org invitation, /handoff saves state plus the reasoning behind it, /save stages, commits, pushes and opens a PR in one command, /activity prints a daily board of sessions, handoffs, and quests, and /deep-reflect spawns parallel analysis agents that read across dozens of artifacts to surface patterns, tensions, and gaps. Installation is one command—npx create-egregore@latest—and the free tier runs entirely locally with no servers, no accounts, and no API keys. The paid Connected tier ($500/month per team) adds hosted organizational memory, connections to Slack, Teams, and Telegram, doc ingestion, and permanent branded surfaces. Egregore+ is a custom tier for teams that want their accumulated record distilled into a model they control, deployed on their own infrastructure.
Behind the Verdict
Egregore's core premise is that a team's knowledge is not documents but traces—the decisions, the trade-offs, the reasoning that produced a piece of work. That premise shapes every surface here. The /handoff command is the clearest example: it doesn't push a status update, it pushes the context graph that generated the update, so the next developer's Claude session picks up the thread with the reasoning intact. /deep-reflect is the most unusual piece of engineering on the page: it spawns a CandidateSelection agent to pick relevant artifacts, then runs parallel DeepAnalysis agents across them and reports consensus, tensions, patterns, and gaps. The sample output—three agents reading 43 artifacts across 3 quests and identifying that an architecture argument is really an argument about time horizon—is the kind of finding a human retrospective rarely produces. Strengths: the free tier is genuinely usable and runs offline with no API keys, which removes the usual procurement friction; the slash-command surface means zero context switching; /save enforces git hygiene automatically; and the paid tier's doc ingestion lets you query existing documents alongside meetings and decisions. Weaknesses worth weighing: the tool is tightly coupled to CLI assistants it names—Claude Code, Codex, and Pi—so its value collapses if your team writes code in Cursor or VS Code with Copilot. Everything is terminal-native, which is a feature for the target user and a hard blocker for anyone who needs a browsable web dashboard. The jump from a free local tier to $500/month hosted is steep with nothing in between, so small teams either stay local or face a serious line item. /deep-reflect's output is only as good as the traces you feed it—a team that doesn't hand off consistently will see thin results. Where it fits: AI-native product teams of roughly 5-50 engineers who use Claude Code daily, hand work between people frequently, and care about why a decision was made rather than just what shipped. Where it doesn't: agencies with rotating contractors, teams standardized on non-CLI tooling, or organizations that want a conventional wiki that non-engineers can browse.
Researching Egregore? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Egregore actually fits — and what changes day-one when you adopt it.
Installs with npx create-egregore@latest, signs in with GitHub OAuth, and has the team run /handoff at the end of each work session for two weeks.
Outcome: Every handoff carries the reasoning behind the work, so the next developer's Claude session starts with context instead of a status ping, and the lead reads /activity instead of running a daily standup.
Runs /deep-reflect on the architecture disagreement that has blocked the feature across three quests and 43 artifacts.
Outcome: Three parallel analysis agents return consensus on the core finding and flag a tension where the same handoff is cited for opposite conclusions, giving the developer a specific variable to resolve rather than a vague dispute.
Accepted via /invite, which sends the GitHub org invitation, grants memory access, and links the knowledge graph before their first session.
Outcome: They start with the organization's accumulated context already in their Claude session and can query prior decisions directly instead of reading a stale onboarding doc.
Use Cases
- Invite a teammate with /invite so they have the org's accumulated context from their first session.
- Hand off work with /handoff so the next developer's Claude session inherits decisions, trade-offs, and open threads.
- Run /save to stage, commit, push, and open a PR without leaving the terminal.
- Replace the standup with /activity, which shows sessions, handoffs, and quest momentum for the day.
- Use /deep-reflect to find patterns and tensions across dozens of artifacts before an architecture decision.
- Bring existing docs into Connected memory and query them alongside meetings and decisions.
- Onboard a new hire faster by handing them a context graph rather than a folder of stale docs.
Models Under the Hood
as of 2026-10-15
Limitations
- Features are delivered as slash commands inside CLI assistants—evidenced against Claude Code and stated to work across Claude Code, Codex, and Pi—so the tool's value depends on your team standardizing on one of those.
- There is no web dashboard for browsing knowledge; everything is terminal-native.
- The Free tier is open source at $0 and runs locally with no servers or accounts.
- Connected is $500/month per team and adds hosted organizational memory plus Slack, Teams, and Telegram connections.
- Egregore+ is priced only via contact at info@egregore.xyz for on-premise deployment and a fine-tuned organization model.
- Installation is via the npm ecosystem: npx create-egregore@latest.
as of 2026-09-27
Verification history
We have re-verified Egregore 10 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 10 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Egregore tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Free
$0/forever
Ideal for
Solo developers and small teams on Claude Code who want shared memory without paying anything or sending data to a hosted service.
What this tier adds
Starting tier: $0/forever, open source, runs entirely locally with no servers, accounts, or API keys. Includes /invite, /handoff, /save, /activity, /deep-reflect, search across everything written, and temporary rendered links.
Connected
$500/month
Ideal for
Engineering organizations of roughly 10-50 people where handoffs and decisions are frequent enough that lost context has real cost.
What this tier adds
Adds hosted organizational memory over Free: a living graph of people, decisions, handoffs, meetings, and artifacts, context restored into every session, doc ingestion and querying, permanent branded surfaces, Slack/Teams/Telegram connections, and guided setup.
Egregore+
Custom
Ideal for
Enterprises with data-residency or governance requirements that need their accumulated record turned into a model they own and run themselves.
What this tier adds
Adds over Connected: your record distilled into an organization-specific open-source model, training and fine-tuning, memory and runtime on your own infrastructure, governance/audit/retention/SSO, multi-team topology and access scopes.
Where the pricing makes sense
The company stage and team size where Egregore's pricing actually pencils out — and where peers do it cheaper.
For a solo developer or a small studio, the Free tier costs nothing and runs locally, which beats paying Notion or Linear per seat for docs your agents can't read. Connected at $500/month per team is priced for organizations of roughly 10-50 engineers where a lost decision or slow handoff has real cost—below that headcount, a Notion Plus or Linear subscription plus manual discipline is far cheaper.
Setup time & first value
How long it actually takes to get something useful out of Egregore — broken out by persona, not the marketing-page minute.
Solo developer: under 5 minutes—npx create-egregore@latest walks through GitHub OAuth, account selection, and project naming, then you open a new terminal and type egregore. Team on the Free tier: same setup plus an /invite per teammate, so roughly 10 minutes for a small team. Connected tier: guided setup and migration are included, but expect days rather than minutes to bring in existing docs
Switching to or from Egregore
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From Notion or Confluence: bring existing docs into Connected memory and query them alongside meetings, decisions, and handoffs.
- →From manual handoff docs: replace written status updates with /handoff, which captures the reasoning the doc leaves out.
- →From git-only history: /save adds decision context to commits and PRs that commit messages alone don't carry.
- →From a prior CLI memory setup: reinstall with npx create-egregore@latest and point it at your existing project repo.
- ↗To Notion or Linear: export the decisions and handoffs you care about; you lose the agent-readable context graph and terminal delivery.
- ↗To a conventional wiki: copy artifacts out manually; nothing keeps memory synchronized with your Claude Code sessions afterward.
- ↗To a rival memory tool: your artifacts live in the shared memory repo created at install, which you control directly.
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “Egregore”, and we withheld 6: 6 could not be judged, because “Egregore” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Egregore.
Official links
Tools that pair well with Egregore
Common stack mates teams adopt alongside Egregore, with the specific reason each pairing earns its keep.
Mem0
Mem0 is an AI memory layer that gives agents and apps persistent context across sessions
Agentmemory
Agentmemory gives coding agents persistent memory between sessions — local, open-source recall for Claude Code, Cursor and Codex.
MemoryLake
MemoryLake is portable AI memory for ChatGPT, Claude, Codex and Gemini — encrypted, exportable, and shared across every agent you run.
Featured Head-to-Head Comparisons
Egregore vs Presto Voice
For QSR chains looking to boost drive-thru revenue and efficiency, Presto Voice is a proven investment with demonstrable ROI (up to 6% incremental revenue). Egregore is an innovative free tool for software teams using Claude Code but is irrelevant outside that niche. Choose based on your domain: drive-thru operations vs. AI-native development.
Egregore vs Locus Robotics
Egregore is a focused, free tool for Claude Code teams wanting persistent memory, while Locus Robotics is a enterprise-grade physical automation solution for warehouses. For non-technical warehouse operations, Locus is the clear choice; for AI-assisted development teams, Egregore offers unique value at no cost.
Egregore vs Truleo
Truleo and Egregore serve entirely unrelated audiences. Truleo is a paid, specialized law enforcement intelligence platform that connects siloed data and automates lead generation. Egregore is a free, niche tool for development teams using Claude Code to preserve team context. Choose based on your role: detective or developer.
Alternatives to Egregore
View allMem0
Mem0 is an AI memory layer that gives agents and apps persistent context across sessions
Agentmemory
Agentmemory gives coding agents persistent memory between sessions — local, open-source recall for Claude Code, Cursor and Codex.
MemoryLake
MemoryLake is portable AI memory for ChatGPT, Claude, Codex and Gemini — encrypted, exportable, and shared across every agent you run.
Frequently Asked Questions
Best-of guides
Used Egregore? Help shape our editorial sentiment research.