convez.ai
AgenteSegurançaIntermediário
Signet-AI

Signet AI

Signet-AI/signetai

Contexto durável e portável para agentes IA — memória, identidade e segredos sob seu controle

Ver no GitHub
Muito bomPluginScore · de 0 a 100

Camada de contexto local-first para agentes de IA que gerencia memória, identidade, transcripts e segredos em infraestrutura sob seu controle. Oferece recall respaldado por fonte, memória reparável e portabilidade entre diferentes modelos e harnesses de agentes, com 97.6% de precisão em testes de memória longa.

Instalação

$npx convez-ai Signet-AI/signetai

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
315
Forks
43
Acompanhando
3
Saúde
87%
Último commit
há 1 dia
Versão
v1.0.1
Issues abertas
126
Contribuidores
20

Casos de uso

  • Persistir contexto de agentes entre mudanças de modelo ou provedor
  • Gerenciar memória, identidade e secrets de forma auditável e reparável
  • Implementar recall de qualidade produção com source-backing e controle de custódia

Veredito

Signet resolve um problema real em produção: quando memória de agentes deixa de ser feature e vira infraestrutura crítica. Local-first, fonte-backed e reparável — ideal para quem precisa auditar e controlar contexto privado sem depender de APIs hospedadas.

README

A tradução para o português deste README ainda está na fila.

Signet AI

Own your agent's context.

97.6% average LongMemEval answer accuracy Local-first context · source-backed recall · repairable memory · portable across agents

Quick start · Why Signet · Benchmarks · Docs · Discord


Models change. Providers change. Agent shells change. Your context should not.

Your agents are starting to remember projects, users, decisions, documents, conversations, preferences, mistakes, routines, and private working context.

That memory is no longer a feature. It is infrastructure — and custody matters.

Signet is a local-first context layer for AI agents: memory, identity, transcripts, source records, provenance, agent instructions, secrets, and repair tools in infrastructure you control.

Hosted memory APIs are fastest until memory becomes part of your product contract: deletion, provenance, repair, portability, and custody of private context. Signet is for that moment.

Not a hosted memory API. Not a harness-specific plugin. Signet is the durable layer underneath your agents.

Why Signet

ClaimWhy it matters
Local-first custodySQLite, readable workspace files, transcripts, source records, memories, and identity files live where you control them
Source-backed recallEvery useful memory can point back to where it came from
Repairable memoryInspect, edit, supersede, delete, reclassify, and scope bad context
Portable across agentsOne layer works across Claude Code, Codex, OpenCode, OpenClaw, Gemini CLI, Hermes Agent, MCP, SDKs, and apps
Team deployment primitivesSignet includes scoped agents, visibility, auth policy, retention controls, secrets storage, and audit-friendly APIs
Proven recallLongMemEval-tracked recall without giving up governance

You know you need Signet when agent memory is no longer just recall quality. You need to know where context lives, where it came from, who can see it, how it can be corrected, what gets deleted, and whether it can move when your tools change.

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.

Proof in one repair loop

Run this once:

signet remember "Project Atlas deploys only after QA signs off" \
  --tags project-atlas --who user
signet recall "Project Atlas deploy policy" --tags project-atlas --json

Then open the dashboard:

signet dashboard

This is the smallest proof, but it shows the product shape: the memory is local, queryable, tagged, visible in the dashboard, and repairable instead of being trapped behind a hosted recall response.

If recall returns a stale deployment policy, you can edit or delete the memory, run the same recall again, and verify the agent is seeing corrected context before it acts.

In the dashboard, the record is not a black-box snippet:

Memory: Project Atlas deploys only after QA signs off
Tags: project-atlas
Dashboard actions: edit · delete · mark pinned · similar
Daemon lifecycle: modify · forget · recover

How Signet is different

AlternativeGood forWhere Signet is different
Hosted memory APIsFast prototypes and managed memorySignet keeps storage, provenance, ranking policy, repair, deletion, and self-hosting under your control
Harness-specific pluginsImproving memory inside one agent shellSignet runs underneath many harnesses, so context survives tool churn
Vector/RAG memorySearching notes and documentsSignet keeps transcripts, identity, source records, repair history, and scoped recall
Lightweight local storesSimple private persistenceSignet adds provenance, dashboard inspection, team policy, connectors, MCP, SDKs, and daemon APIs
Stay hosted if...Switch to Signet when...
You need the fastest managed API pathMemory has to live in infrastructure you control
Recall quality is the only contractDeletion, repair, provenance, and auditability are also part of the contract
One app owns the memory surfaceMultiple agents, harnesses, SDKs, MCP clients, or internal apps need the same context
Vendor-managed ranking is acceptableYou need to inspect and tune recall policy around your own sources
You cannot run a daemon or own backups yetYou need an exportable workspace you can inspect, back up, and move

Operating tradeoff

Signet is infrastructure, not a hosted shortcut. You run a local or self-hosted daemon, choose an embedding provider, back up $SIGNET_WORKSPACE/, and connect your harnesses through hooks, MCP, connectors, or SDKs.

The trade is deliberate: you operate the memory layer, and in return you can inspect, repair, scope, self-host, back up, and move the context your agents depend on.

For a single-developer install, day two is usually signet status, a workspace backup, and rerunning setup when you add or replace an agent harness.

Is Signet right for you?

Use Signet if you want:

  • agents that remember across sessions without prompt bootstrapping
  • memory your team can inspect, repair, scope, and self-host
  • source-backed recall across private docs, repos, conversations, and artifacts
  • one memory layer across agent harnesses, MCP clients, SDKs, and custom apps

Signet may be overkill if you only need short-lived chat memory inside a single hosted assistant or a simple vector search endpoint.

Harness support

Signet is not trying to win by being another agent shell. It runs underneath the tools people already use and gives them one owned memory layer.

HarnessIntegration pathNotes
Claude CodeHooks + MCPDirect /remember and /recall skills
OpenCodePlugin + hooksRuntime plugin with lifecycle support
OpenClawRuntime pluginFlagship path; hooks available for legacy setups
CodexMCP + compatibility hooksMCP-first integration; plugin bundle when available
Hermes AgentMemory provider pluginmemory_*, recall, and remember tools
PiExtension + hooksMemory commands and agent-callable tools
Oh My PiManaged extensionLifecycle recall injection through the managed extension
Gemini CLIMCP + GEMINI.md syncOn-demand tools plus identity sync

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

Memory that holds up

Signet's latest tracked MemoryBench run averages 97.6% LongMemEval answer accuracy under the rules profile.

The benchmark matters because local custody should not mean weak recall. Signet is designed to retrieve the right facts across long-running, multi-session conversations while keeping memory inspectable and repairable.

That profile keeps the benchmark contract strict: memories are ingested through /api/memory/remember, recalled through /api/memory/recall, and answered from bounded daemon recall results. Search does not call an LLM.

See Benchmarks for the methodology, scoring note, and run workflow.

Install (detailed)

curl -fsSL https://signetai.sh/install.sh | bash
npm install -g signetai
bun add -g signetai
signet setup               # interactive setup wizard

curl, npm, and Bun all install the same compiled Signet binary. The npm and Bun package-manager paths install the signetai wrapper plus a platform native package tarball from the same GitHub release. Install scripts only link the native binary into place; if scripts are disabled, the wrapper resolves the native package directly. They do not install Bun, rebuild Signet, or install daemon dependencies. Published native binaries currently cover Linux x64, Linux arm64, macOS x64, macOS arm64, and Windows x64. Windows direct installs should use npm install -g signetai; the old PowerShell install.ps1 path has been removed until a native Windows direct installer ships.

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 window is Fridays" --agent alice --private
signet recall "deploy window" --agent alice  # scoped to alice's visible memories
signet agent info alice                    # identity files, policy, memory count

Use the secrets subsystem for credentials. Do not store tokens or keys as recallable memories.

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

In harnesses with command-style integrations, skills work directly:

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

How it works

Signet separates memory into three layers:

workspace / transcripts
  truth layer: raw files, identity docs, source records, session history

semantic memory
  navigation layer: summaries, entities, decisions, constraints, relations

query layer
  retrieval lens: FTS, vector search, graph traversal, scopes, provenance

The record is preserved first. The daemon indexes it, extracts useful structure, and keeps recall bounded and inspectable. The agent gets the right context before the next prompt starts, with a path back to the raw source when the semantic layer is not enough.

After setup, there is no per-session memory ceremony. The pipeline runs in the background and the agent wakes up with its memory intact.

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

Architecture

Workspace (~/.agents/)
  AGENTS.md, SOUL.md, IDENTITY.md, USER.md, MEMORY.md, transcripts, memory files
  readable source records and agent identity files

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

Daemon (@signet/daemon, localhost:3850)
  |-- HTTP API (memory, retrieval, auth, skills, updates, tooling)
  |-- File Watcher
  |     identity sync, per-agent workspace sync, git auto-commit
  |-- Distillation Layer
  |     extraction -> decision -> graph -> retention
  |-- Retrieval
  |     FTS + vectors + graph traversal -> fusion -> dampening
  |-- Lossless Transcripts
  |     raw session storage -> expand-on-recall join
  |-- Document Worker
  |     ingest -> chunk -> embed -> index
  |-- Ranking + Feedback
  |     bounded candidate ordering, provenance, source-aware scoring
  |-- MCP Server
  |     tool registration, aggregation, blast radius endpoint
  |-- Auth Middleware
  |     local / team / hybrid, RBAC, rate limiting
  |-- Multi-Agent
        roster sync, agent_id scoping, read-policy SQL enforcement

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

SDK (@signet/sdk)
  typed client, React hooks, Vercel/OpenAI helpers, plugin-facing primitives

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

Repository map

See Repository Map for package layout, internal surfaces, and ownership boundaries.

Documentation

Research

Paper / ProjectRelevance
Lossless Context Management (Voltropy, 2026)Hierarchical summarization, guaranteed convergence. Related runtime notes live in lossless-working-memory-runtime.md.
Recursive Language Models (Zhang et al., 2026)Active context management. LCM builds on and departs from RLM's approach.
acpx (OpenClaw)Agent Client Protocol. Structured agent coordination.
lossless-claw (Martian Engineering)LCM reference implementation as an OpenClaw plugin.
openclaw (OpenClaw)Agent runtime reference.
arscontextaAgentic notetaking patterns.
ACAN (Hong et al.)LLM-enhanced memory retrieval for generative agents.
Kumiho (Park et al., 2026)Prospective indexing. Hypothetical query generation at write time. Reports 0.565 F1 on the official split and 97.5% on the adversarial subset.

Development

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

bun install
bun run build
bun test
bun run lint
cd platform/daemon && bun run dev     # Daemon dev (watch mode)
cd surfaces/dashboard && bun run dev  # Dashboard dev

Requirements:

  • Bun for normal repo development
  • Node.js 18+ for Node-targeted package surfaces
  • macOS or Linux
  • Optional for harness integrations: Claude Code, Codex, OpenCode, OpenClaw, Gemini CLI, Pi, Oh My Pi, or Hermes Agent

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.

Star History

Contributors

Made with love by...

License

Apache-2.0.


signetai.sh · docs · spec · discussions · issues

Ver o original no GitHub

Bom para

Relacionados