S I G N E T A I

Bring your own context to any AI agent

97.6% average LongMemEval answer accuracy Readable record · inspectable recall · harnesses are replaceable

Website · Docs · Benchmarks · Vision · Discussions · Discord · Contributing · AI Policy

Models change. Harnesses change. Providers change. Your context should not.

Signet is the portable context layer for AI agents. It keeps identity, memory, provenance, secrets, skills, and working knowledge outside any single chat app, model provider, or harness. The execution surface can change. The agent keeps its footing.

The job is simple: bring your own context to the agents you already use, then keep that context inspectable and under your control. Signet runs beneath Claude Code, OpenCode, OpenClaw, Codex, Gemini CLI, Pi, Oh My Pi, Hermes Agent, and other harnesses so the durable layer survives the tool of the week.

Memory is ambient. Signet captures useful context between sessions, preserves the raw record, indexes it for recall, and injects relevant context before the next prompt starts. The agent wakes up with continuity instead of asking you to rebuild the room by hand.

Why teams adopt it:

• less prompt re-explaining between sessions
• one context layer across agents, models, harnesses, and providers
• local-first storage with inspectable provenance and repair tools
• a path away from harness-locked behavioral context

Quick start (about 5 minutes)

curl -fsSL https://signetai.sh/install.sh | bash
signet setup               # interactive setup wizard
signet status              # confirm daemon + pipeline health
signet dashboard           # open memory + retrieval inspector

If you already use Claude Code, OpenCode, OpenClaw, Codex, Gemini CLI, Pi, Oh My Pi, or Hermes Agent, keep your existing harness. Signet installs under it.

Docker self-hosting

Run Signet as a containerized daemon with first-party Compose assets:

cd deploy/docker
cp .env.example .env
docker compose up -d --build

See docs/SELF-HOSTING.md for token bootstrap, backup, and upgrade runbook details.

Bring your own context

Portable memory only matters if the agent can see the world you already work inside. Signet is built around ordinary context, not a special knowledge-base ritual: project notes, transcripts, markdown files, PDFs, URLs, identity files, decisions, preferences, and the corrections that shape how work actually happens.

The durable record stays readable. The semantic layer helps the agent navigate it. Retrieval is a lens over the record, not a replacement for it. When a summary is stale, conflict-heavy, or decision-critical, the agent can climb back down to the source.

First proof of value (2-session test)

Run this once:

signet remember "my primary stack is bun + typescript + sqlite"

Then in your next session, ask your agent:

what stack am i using for this project?

You should see continuity without manually reconstructing context. If not, inspect recall and provenance in the dashboard or run:

signet recall "primary stack"

Want the deeper architecture view? Jump to How it works or Architecture.

Core capabilities

These are the product surface areas Signet is optimized around:

| Core | What it does | |---|---| | 🧠 Ambient memory | Sessions are captured automatically, no manual memory ceremony required | | 🗂️ Source-backed context | Raw transcripts and workspace files remain available beneath summaries and recall results | | 🎯 Inspectable recall | Hybrid search, graph traversal, provenance, scopes, and ranking signals explain why context surfaced | | 🏠 Local-first substrate | Data lives on your machine in SQLite and markdown, portable by default | | 🤝 Cross-harness continuity | Claude Code, OpenCode, OpenClaw, Codex, Gemini CLI, Pi, Oh My Pi, Hermes Agent, one shared context layer | | 🧩 SDK-first extensibility | Typed SDKs, middleware, and plugin surfaces let builders shape Signet around their own agents |

Is Signet right for you?

Use Signet if you want:

• memory continuity across sessions without manual prompt bootstrapping
• local ownership of agent state and history
• one context layer across multiple agent harnesses

Signet may be overkill if you only need short-lived chat memory inside a single hosted assistant.

What Signet is not

Signet is not a chat app, not a harness, and not a fake second brain trying to outsmart the model. It is the durable layer underneath: files, memory, identity, provenance, retrieval, secrets, and permissions.

The harness should stay replaceable. The provider should provide intelligence, not custody. Signet keeps the continuity somewhere you can inspect, repair, move, and rebuild.

Why you can trust this

• runs local-first by default
• raw records and workspace files stay inspectable
• SQLite powers the query layer; recall keeps provenance and source references
• memory can be repaired (edit, supersede, delete, reclassify)
• easy to build on: SDK, connectors, MCP, and workspace primitives let teams shape Signet around their agents, policies, and workflows
• no vendor lock-in, your context stays portable

If you are building agents for an organization, Signet is meant to be shaped, not merely installed. Use the SDK, plugin SDK, connectors, and MCP surface to fit your own agents, permission model, workflows, and deployment style.

What keeps it reliable

These systems improve quality and reliability of the core memory loop:

| Supporting | What it does | |---|---| | 📜 Lossless transcripts | Raw session history preserved alongside extracted memories | | 🕸️ Structured retrieval substrate | Graph traversal + FTS5 + vector search produce bounded candidate context | | 🎯 Feedback-aware ranking | Recency, provenance, importance, and dampening signals help separate useful context from repeated noise | | 🔬 Noise filtering | Hub and similarity controls reduce low-signal memory surfacing | | 📄 Document ingestion | Pull PDFs, markdown, and URLs into the same retrieval pipeline | | 🖥️ CLI + Dashboard | Operate and inspect the system from terminal or web UI |

Advanced capabilities (optional)

These extend Signet for larger deployments and custom integrations:

| Advanced | What it does | |---|---| | 🔐 Agent-blind secrets | Encrypted secret storage, injected at execution time, not exposed to agent text | | 👯 Multi-agent policies | Isolated/shared/group memory visibility for multiple named agents | | 🔄 Git sync | Identity and memory can be versioned in your own remote | | 📦 SDK + plugin SDK | Typed client, React hooks, Vercel/OpenAI helpers, and plugin surfaces for extending the ecosystem | | 🔌 MCP aggregation | Register MCP servers once, expose across connected harnesses | | 👥 Team controls | RBAC, token policy, and rate limits for shared deployments | | 🏪 Ecosystem installs | Install skills and MCP servers from skills.sh and ClawHub | | ⚖️ Apache 2.0 | Fully open source, forkable, and self-hostable |

When memory is wrong

Memory quality is not just recall quality. It is governance quality.

Signet is built to support:

• provenance inspection (where a memory came from)
• scoped visibility controls (who can see what)
• memory repair (edit, supersede, delete, or reclassify)
• transcript fallback (verify extracted memory against raw source)
• lifecycle controls (retention, decay, and conflict handling)

Harness support

Signet is not a harness. It doesn't replace Claude Code, OpenClaw, OpenCode, Codex, Gemini CLI, Pi, Oh My Pi, or Hermes Agent - it runs alongside them as an enhancement. Bring the harness you already use. Signet handles the memory layer underneath it.

| Harness | Status | Integration | |---|---|---| | Claude Code | Supported | Hooks | | OpenCode | Supported | Plugin + Hooks | | OpenClaw | Supported | Runtime