<div align="center"> <img src="./assets/sigil.svg" alt="Sigil" width="100" height="100" />

Sigil

Your machine. Every agent. One brain.

Local-first memory shared across Claude Code, Codex CLI, Cursor, Kiro, and any agent that can run a shell command or speak MCP. Stored in your own Postgres. No cloud, no telemetry.

</div>

curl -fsSL https://raw.githubusercontent.com/Anmol-Srv/sigil/master/install.sh | sh

That's it. The installer clones Sigil into ~/.sigil/app, puts it on your PATH persistently, then launches it and opens a dashboard in your browser where you configure everything — database, LLM, and embedding provider — with live connection tests and one-click fixes. No config files to edit, no setup prompts in the terminal.

Update any time with:

sigil update

It fast-forwards your install to the latest release — git is the source of truth, so there's no package to reinstall. The background daemon also checks periodically and tells you when an update is available.

Why git, not npm? Sigil is persistent infrastructure (a background daemon + editor hooks pinned to a path). It installs as a git clone and updates with git pull under the hood; pushing to the release branch is the release. npx/pnpx was never viable — it runs from a throwaway cache your package manager later deletes, which would silently break memory, so Sigil refuses to set up from there.

<div align="center">

Configure in the dashboard. Open Claude Code. Memory is already wired in.

Quickstart · Every agent · How it works · Capabilities · Benchmarks · FAQ

</div>

---

Why this exists

Every memory tool for AI agents ships as someone else's cloud. Your code context, your team's decisions, your preferences: all sitting in a vendor's database. That's the wrong default for the most intimate context your agents touch.

And every agent has its own walled memory. Claude doesn't see what you told Codex. Cursor doesn't know what Kiro learned this morning. You re-explain the same architecture, watch the same mistakes happen, lose hours to context-loading every session.

Sigil fixes both problems with the same primitive: a local memory layer every agent connects to.

• In Claude Code: four hooks (UserPromptSubmit, PostToolUse, Stop, SessionEnd) auto-capture decisions, preferences, and observations as you work. Relevant memory is injected into every new prompt before Claude sees it. You write zero sigil remember calls.
• Everywhere else, the sigil CLI is the universal interface. Any agent that can run a shell command (Codex CLI, terminal-based assistants, CI runners, Hermes, your own scripts) can call sigil search "..." or sigil remember "..." directly. No client integration required: if the agent can shell out, it can read and write memory.
• For MCP-aware clients (Cursor, Continue, Cline, Windsurf, Claude Desktop, Kiro): the same memory is also exposed as a 9-tool MCP server. Same brain, structured surface for clients that prefer it.
• Across machines: point multiple installs at the same Postgres. A fact captured on your laptop surfaces in the agent running on your home server. No daemon, no sync protocol. Postgres handles consistency.

The pod model (sessions, projects, people, playbooks, vitals, and any pluggable kind you add) is the foundation. It's how the next layers (write-attributed multi-agent workflows, ACLs, custom integrations) will land on top of the same brain.

What changes in practice: Tuesday in Claude Code, you decide to route webhooks through Postgres LISTEN/NOTIFY instead of Redis pubsub. Thursday you open Cursor in the same repo and ask for an event handler. It already knows. Friday you spin up a Hermes agent on your home server and ask "what's our event delivery setup?". Same answer, no copy-paste. The brain travels with you.

---

Works with every agent on your machine

Sigil's wedge is one memory layer underneath everything. sigil init detects every coding agent on your machine and wires Sigil into each one automatically: hooks for Claude Code, MCP server registration plus client-native steering rules for the rest.

| Agent | Integration depth | Auto-wired | |---|---|---| | Claude Code | Native plugin · 4 hooks (UserPromptSubmit, PostToolUse, Stop, SessionEnd) · MCP server · @~/.sigil/CLAUDE.md hot-context import | ✓ | | Codex CLI | ~/.codex/config.toml MCP entry · ~/.codex/AGENTS.md steering · MCP server | ✓ | | Cursor | ~/.cursor/mcp.json MCP entry · MCP server | ✓ | | Kiro | ~/.kiro/settings/mcp.json MCP entry · ~/.kiro/steering/sigil.md steering rule · MCP server | ✓ | | Continue / Cline / Windsurf | MCP server (one-line config from sigil register --print) | - | | Hermes / OpenClaw / any custom agent | MCP server, REST, or sigil CLI directly | - | | Any MCP-spec client | MCP server | - |

Works with any agent that speaks MCP or can run a shell command. One brain on your machine. Every agent reads and writes to it.

Two interfaces: CLI first, MCP when it fits

The sigil CLI is the universal interface. If your agent has a Bash tool, a terminal, or any way to shell out, it can use Sigil with no client-specific integration required:

sigil search "JWT auth setup"            # what does the brain know?
sigil remember "we use jose, not jsonwebtoken"  # save a fact
sigil facts --limit=20                   # list recent facts
sigil why "auth setup"                   # explain the search

That's exactly how Claude Code (via Bash tool), Codex CLI, terminal-based agents, Hermes, and your own CI scripts use Sigil today. The CLI is auto-detected on PATH once installed (via the curl … | sh installer); agents discover it the same way they discover git or node.

For clients that prefer structured tool calls (Cursor, Continue, Cline, Claude Desktop, Kiro, any MCP-spec agent), Sigil also exposes the same memory as a 9-tool MCP server. sigil register --print generates the config. MCP is the second interface, not the only one.

vs your agent's built-in memory

Every coding agent ships with a hand-edited memory file: CLAUDE.md, AGENTS.md, .cursorrules, Kiro steering. They're per-agent, capped in size, manually maintained, and reloaded in full on every prompt. Sigil is the searchable brain behind them.

| | Built-in (CLAUDE.md, AGENTS.md, etc.) | Sigil | |---|---|---| | Capture | Manual; you write and edit the file | Automatic via Claude Code hooks | | Scale | Loaded fully into context every prompt | Top-K retrieved from unlimited corpus | | Token cost | Linear in file size (caps how much you can store) | ~1.5K injected per prompt regardless of corpus size | | Search | None; the model reads the whole file | Hybrid (pgvector + tsvector BM25 + RRF) | | Cross-agent | Per-agent files, no sharing | One shared brain across every wired agent | | Cross-machine | Manual sync (git, scp) | Point installs at the same Postgres | | Freshness | Stale until you rewrite | Auto-decay, supersession, importance reweighting | | Provenance | None | Every fact links to source + confidence + temporal validity |

You can keep using CLAUDE.md for hard-coded project rules. Sigil handles everything else.

---

How it's structured

Memory lives in pods: typed containers with declared retrieval behaviour. Five built-in kinds today:

| Kind | Identity | Decay | Hot-context budget | |---|---|---|---| | claude_session | one per Claude Code session | 90 days | 6 slots | | project | one per git root (or cwd) | never | 4 slots | | person | one per contact you mention | never | 4 slots (rolling 24h active) | | playbook | your user-authored runbooks | never | 3 slots (active for matching project) | | vital | virtual; facts marked importance=5 | never | 6 slots (global) |

Pods are pluggable. Adding a new kind (codex_session, slack_channel, github_pr, ...) means writing a contract file. No schema migrations. Retrieval is pod-aware: hot-context blends facts from your active session + project + relevant people + vital, weighted by importance × decay.

Three storage layers underneath:

1. Chunks: raw 512-token blocks of ingested docs, embedded via your chosen provider (Ollama / OpenAI / Voyage)
2. Facts: atomic statements with confidence, importance, temporal validity, supersession links
3. Entity graph: typed nodes (person, project, service, ...) + relations, traversed via recursive CTEs

Retrieval is hybrid: pgvector cosine + tsvector keyword fused via Reciprocal Rank Fusion, then re-ranked by ACT-R activation (recency × frequency) and Hebbian co-retrieval boosts. The full pipeline is in src/memory/.

What each hook does

| Hook | What runs | |---|---| | UserPromptSubmit | Hybrid search on your prompt → top-K facts injected as additionalContext before Claude sees it | | PostToolUse | Capture observations from Edit / Write / Bash; SHA-256 dedup against a 5-minute window | | Stop | Classify the user's last message (preference / decision / constraint / claim), extract atomic facts + entities, AUDM (Add / Update / Delete / Merge) against existing memory to prevent duplicates | | SessionEnd | Summarize the session into its claude_session pod; promote sticky facts to higher importance |

Key capabilities

| Capability | What it gives you | |---|---| | Universal CLI interface | Any agent with shell access can call sigil search / sigil remember directly. Works in Claude Code (Bash tool), Codex CLI, terminal agents, Hermes, CI scripts. No client integration required | | Auto-capture via hooks | Zero manual sigil remember calls in Claude Code; the Stop hook handles routine saves | | Cross-agent shared memory | Claude Code, Codex CLI, Cursor, Kiro all read and write the same brain | | Cross-machine via shared DB | Laptop + home server + cloud agent on one Postgres = one memory | | Hybrid search | pgvector cosine + tsvector BM25 fused via Reciprocal Rank Fusion (one SQL query) | | ACT-R + Hebbian re-ranking | Recency × frequency activation + co-retrieval boosts (cognitive-science model, not vibes) | | Pluggable pods | Five built-in kinds; add slack_channel, github_pr, codex_session, etc. as contract files. No schema migrations | | AUDM dedup | Add / Update / Delete / Merge intelligence stops fact pile-up across thousands of saves | | Fully air-gappable | Pick Ollama for both LLM and embeddings. Zero data leaves your network | | No vendor account | One curl … | sh install + your Postgres = working brain. No signup, no API key required to start | | Hot-context snapshot | Top-20 facts always loaded via @~/.sigil/CLAUDE.md import. Instant context with zero latency | | 9-tool MCP server | search, search_entity, traverse_graph, get_fact_context, get_entity_context, get_pod, list_pods, status, ingest | | Honest benchmarks | Public LongMemEval oracle: R@10 = 100%, 33ms p50 search. Reproducible. No in-house corpus theater |

---

Quickstart

Sigil needs Postgres 13+ with the pgvector extension running somewhere reachable. You bring the server; the dashboard does everything else.

1. Install & launch

curl -fsSL https://raw.githubusercontent.com/Anmol-Srv/sigil/master/install.sh | sh

This installs Sigil persistently (on your