S I G N E T A I

Local-first persistent memory for AI agents

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

Persistent memory for AI agents, across sessions, tools, and environments.

TL;DR

• Installs under your existing harness, not instead of it
• Captures and injects relevant memory automatically between sessions
• Runs local-first, with inspectable storage and no vendor lock-in

Most agents only remember when explicitly told to.

That is not memory, that's a filing cabinet.

Signet makes memory ambient. It extracts and injects context
automatically, between sessions, before the next prompt starts.
Your agent just has memory.

Structured memory, graph traversal, and hybrid retrieval matter, but
they are not the point. They are substrate for the larger job Signet is
building toward: deciding what should enter the model's context window
right now, with enough precision to help instead of distract.

Why teams adopt it:

• less prompt re-explaining between sessions
• one memory layer across Claude Code, OpenCode, OpenClaw, Codex, and Hermes Agent
• clear visibility into what was recalled, why, and from which scope

Benchmark note: early LoCoMo results show 87.5% answer accuracy
and 100% Hit@10 retrieval on an 8-question full-stack sample.
Larger evaluation runs are in progress. Details

Quick start (about 5 minutes)

bun add -g signetai        # or: npm install -g signetai
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, 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.

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:

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 memory layer across multiple agent harnesses

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

Why you can trust this

• runs local-first by default
• memory is stored in SQLite + markdown
• recall is inspectable with provenance and scopes
• memory can be repaired (edit, supersede, delete, reclassify)
• no vendor lock-in, your data stays portable

What keeps it reliable

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

Advanced capabilities (optional)

These extend Signet for larger deployments and custom integrations:

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, Pi, or Hermes Agent — it runs alongside them as an enhancement.
Bring the harness you already use. Signet handles the memory layer
underneath it.

Don't see your favorite harness? file an issue and request that it be added!

LoCoMo Benchmark

LoCoMo is the standard benchmark
for conversational memory systems. No standardized leaderboard exists —
each system uses different judge models, question subsets, and evaluation
prompts. These numbers are collected from published papers and repos.

Current Signet run: 87.5% answer accuracy, 100% Hit@10 retrieval, MRR 0.615 on an 8-question sample.

We treat this as an encouraging early signal, not a final claim. The sample
size is small and larger-scale runs are in progress.

What this result does show today:

• retrieval hit rate was 100% for this run (no empty recalls)
• the correct supporting memory typically surfaced near the top (MRR 0.615)
• search-time recall operated without extra LLM inference calls

See Benchmarks for methodology, progression, and
how to run your own evaluation.

Install (detailed)

bun add -g signetai        # or: npm install -g signetai
signet setup               # interactive setup wizard

The wizard initializes $SIGNET_WORKSPACE/, configures your harnesses, sets up
an embedding provider, creates the database, and starts the daemon.

Path note: $SIGNET_WORKSPACE means your active Signet workspace path.
Default is ~/.agents, configurable via signet workspace set <path>.

Tell your agent to install it

Paste this to your AI agent:

Install and fully configure Signet AI by following this guide exactly: https://signetai.sh/skill.md

CLI use

signet status              # check daemon health
signet dashboard           # open the web UI

signet remember "prefers bun over npm"
signet recall "coding preferences"

Multi-agent

Multiple named agents share one daemon and database. Each agent gets its
own identity directory (~/.agents/agents/<name>/) and configurable
memory visibility:

signet agent add alice --memory isolated   # alice sees only her own memories
signet agent add bob --memory shared       # bob sees all global memories
signet agent add ci --memory group --group eng  # ci sees memories from the eng group

signet agent list                          # roster + policies
signet remember "deploy key" --agent alice --private  # alice-only secret
signet recall "deploy" --agent alice       # scoped to alice's visible memories
signet agent info alice                    # identity files, policy, memory count

OpenClaw users get zero-config routing — session keys like
agent:alice:discord:direct:u123 are parsed automatically; no
agentId header needed.

In connected harnesses, skills work directly:

/remember critical: never commit secrets to git
/recall release process

How it works

session ends
  → raw transcript is preserved and distilled into structured memory
  → entities, constraints, and relations are linked into a navigable graph
  → traversal + flat search build a bounded candidate pool
  → predictive scorer reranks candidates against your interaction patterns
  → fail-open guards keep baseline ordering if the model is cold or unavailable
  → post-fusion dampening separates signal from noise
  → right context injected before the next prompt starts

No configuration required. No tool calls. The pipeline runs in the
background and the agent wakes up with its memory intact.

Read more: Why Signet · Architecture · Knowledge Graph · Pipeline

Architecture

CLI (signet)
  setup, knowledge, secrets, skills, hooks, git sync, service mgmt

Daemon (@signet/daemon, localhost:3850)
  |-- HTTP API (modular endpoints for memory, retrieval, auth, and tooling)
  |-- Distillation Layer
  |     extraction -> decision -> graph -> retention
  |-- Retrieval
  |     traversal + flat search -> fusion -> dampening
  |-- Lossless Transcripts
  |     raw session storage -> expand-on-recall join
  |-- Hints Worker
  |     prospective indexing -> FTS5 index
  |-- Inline Entity Linker
  |     write-time entity extraction (no LLM), decision auto-protection
  |-- Predictive Scorer
  |     learned relevance model over structured candidates
  |-- Document Worker
  |     ingest -> chunk -> embed -> index
  |-- MCP Server
  |     tool registration, aggregation, blast radius endpoint
  |-- Auth Middleware
  |     local / team / hybrid, RBAC, rate limiting
  |-- File Watcher
        identity sync, per-agent workspace sync, git auto-commit
  |-- Multi-Agent
        roster sync, agent_id scoping, read-policy SQL enforcement

Core (@signet/core)
  types, identity, SQLite, hybrid search, graph traversal

SDK (@signet/sdk)
  typed client, React hooks, Vercel AI SDK middleware

Connectors
  claude-code, opencode, openclaw, codex, oh-my-pi, pi, hermes-agent, forge

Packages

Documentation

• Quickstart
• CLI Reference
• Configuration
• Hooks
• Harnesses
• Secrets
• Skills
• Auth
• Dashboard
• SDK
• API Reference
• Knowledge Architecture
• Knowledge Graph
• Benchmarks
• Roadmap

Research

Development

git clone https://github.com/Signet-AI/signetai.git
cd signetai

bun install
bun run build
bun test
bun run lint

cd packages/daemon && bun run dev        # Daemon dev (watch mode)
cd packages/cli/dashboard && bun run dev # Dashboard dev

Requirements:

• Node.js 18+ or Bun
• macOS or Linux
• Optional for harness integrations: Claude Code, Codex, OpenCode, or OpenClaw

Embeddings (choose one):

• Built-in (recommended) — no extra setup, runs locally via ONNX (nomic-embed-text-v1.5)
• Ollama — alternative local option, requires nomic-embed-text model
• OpenAI — cloud option, requires OPENAI_API_KEY

Contributing

New to open source? Start with Your First PR.
For code conventions and project structure, see
CONTRIBUTING.md. Open an issue before
contributing significant features. Read the
AI Policy before submitting AI-assisted work.

Contributors

Made with love by members of Dashore Incubator & friends of Jake Shore and Nicholai Vogel.

License

Apache-2.0.

signetai.sh ·
docs ·
spec ·
discussions ·
issues