Signet AI

Signet AI is a memory layer designed to store, sync, and share memories, system prompts, transcripts, institutional knowledge, and secrets across different AI harnesses and models.

Core Concepts

• Dreaming: A background process that constructs a living semantic ontology (a structured representation of your world) from raw history like transcripts and imported files. This turns raw data into connected memory with an audit trail.
• Memory Graph: Signet builds a structured representation of your data, allowing agents to retrieve relevant context before a prompt starts.
• Audit Trail: Every piece of memory maintains a path back to its raw source, which is useful for debugging and establishing trust.

Signet is a local-first memory and context layer designed for AI agents. It operates as a daemon running alongside an agent's existing tools to maintain an inspectable workspace, evidence, search indexes, and structured knowledge.

Core Components

• Dashboard: The visual interface for inspecting state.
• signet CLI: Used to install, configure, and operate the local service.
• Harness Integrations: Connect to the daemon via an HTTP API to interact with the local state during agent operations.

Signet is not a model provider or a replacement for an agent harness; it is infrastructure to make agent context durable, scoped, and useful across different sessions and interfaces.

The signet.secrets plugin is the reference core plugin for the Signet plugin system. It provides the infrastructure for managing local encrypted secrets.

Key capabilities provided by this plugin include:

• Daemon Routes: API endpoints for secret management.
• CLI Commands: Interface for interacting with secrets via the command line.
• MCP Tools: Model Context Protocol tools for AI agents to access secrets.
• Dashboard Metadata: Information for UI visualization.
• SDK Surfaces: Programmatic access via the Signet SDK.
• Connector Capabilities: Integration points for various connectors.
• Prompt Guidance: Contextual instructions for LLMs.
• Health Checks & Audit Metadata: Monitoring and security auditing for secret access.

Signet is a local-first memory and context layer designed for AI agents. It provides a way to preserve raw work artifacts (transcripts, notes, documents, decisions) as ground truth and builds a semantic layer on top of them with provenance chains.

Key value propositions:

• Portability: Memory, system-prompts, skills, and secrets travel with the user across different machines, models, and AI harnesses.
• Durability: Prevents context loss (flattening) that occurs in typical compacted LLM sessions.
• Security: Provides measured access to credentials (Signet secrets) where a daemon injects values at execution time and redacts them from downstream processes.

The Memory API manages the complete lifecycle of memories within the Signet system. It provides capabilities for raw-first writes, retrieval, revision, recall, and embedding inspection. The API is structured into three primary functional areas:

1. Write Lifecycle: Operations to create, read, modify, recover, and forget memories.
2. Recall and Search: Mechanisms for running hybrid recall, direct search, and similarity-based queries.
3. Embeddings: Tools to inspect embedding records, monitor worker health, and view projections.

For details on authentication and envelope conventions required to use these endpoints, refer to the HTTP API overview.

The Pi integration connects Signet's memory system to Pi via its extension mechanism. It performs the following tasks:

• Installs a managed Signet extension into the Pi extensions directory.
• Configures the agent workspace path in Pi's config.json.
• Detects and resolves multiple candidate agent directories.
• Ships a bundled extension that is written to disk on installation.
• Exposes the following Signet-specific tools to the Pi agent:
  • signet_recall
  • signet_source_search
  • signet_session_search
  • signet_remember

The OpenClaw connector integrates Signet's memory system into OpenClaw's hook and workspace configuration.

Key actions performed by the connector:

• Patches OpenClaw configuration to set agents.defaults.workspace to ~/.agents.
• Enables the signet-memory internal hook entry.
• Installs hook handler files for the following commands: /remember, /recall, and /context.
• Supports JSON5 configuration parsing (required for OpenClaw's .json5 or JSONC config files).

Note: Unlike other connectors, this integration does not require a generated output file because OpenClaw reads ~/.agents/AGENTS.md directly.

The SDK provides four distinct entry points depending on your integration needs:

• @signet/sdk: The core client, including SignetClient, error classes, and public types.
• @signet/sdk/react: Provides a React provider and specialized memory hooks.
• @signet/sdk/ai-sdk: Provides adapters for the Vercel AI SDK.
• @signet/sdk/openai: Provides adapters for OpenAI function-tooling.

The OpenCode integration connects Signet's memory system to OpenCode via its plugin system. Key features include:

• Plugin Management: Bundles and writes signet.mjs to ~/.config/opencode/plugins/.
• Identity Management: Generates AGENTS.md from identity files in your agent workspace.
• Configuration: Registers the plugin in OpenCode's configuration files (opencode.json, opencode.jsonc, or config.json) while preserving JSONC comments and formatting.
• Tool Access: Symlinks the skills directory for tool access.
• Memory Normalization: Normalizes memory_search requests through Signet's canonical recall contract. The scope parameter accepts exact daemon memory scopes (e.g., world:alpha).
• Legacy Migration: Automatically migrates away from the legacy memory.mjs approach during installation or uninstallation.

Signet is organized by developer intent rather than a single packages/ directory. Understanding this structure helps you locate core engine code, user interfaces, or integration components.

Top-level directory organization

• platform/: Engine and runtime code (e.g., core, daemon, predictor, native).
• surfaces/: Human-facing interfaces (e.g., CLI, dashboard, desktop, tray, extension).
• integrations/: External harness integrations, grouped by the tool they support.
• plugins/: Signet-native plugins that are loaded directly by Signet.
• libs/: Reusable developer libraries.
• dist/: Assembled shipping artifacts.
• web/: Marketing site and Cloudflare workers.
• memorybench/: Benchmark harness, datasets, providers, reports, and UI.