What Is Signet

Signet is the layer between AI agents and AI models.

Models are reasoning engines. They’re powerful, but stateless — every session starts fresh, every tool switch resets everything, and the model has no memory of who you are or what you’ve been working on.

Signet fixes that by giving agents a persistent home. Identity, knowledge, Secrets, and Skills all live in that home, independent of whichever model happens to be running. The model is a guest. It reads what it needs, does its work, and writes back what it learned. Swap the model out entirely and the agent stays the same entity.

The simplest analogy: Signet is a home directory for AI agents.

Why This Matters

Today, your AI assistant is tied to a platform. ChatGPT’s memory belongs to OpenAI. Claude’s memory belongs to Anthropic. Switch tools and you start over. Cancel your subscription and everything disappears.

Signet moves the center of gravity from the AI company to the user. Your agent’s identity and knowledge live on your machine, in files and a database you own. You can inspect every memory, back up everything, and carry it to any tool that supports the standard.

The agent becomes portable. The model becomes interchangeable.

The Architecture in One Picture

Most people think of the AI stack as:

applications
models
hardware

Signet introduces a layer that doesn’t exist yet:

applications
agents
persistent cognition layer  ← Signet
models
hardware

Historically, the layers between systems tend to become foundational. TCP/IP sits between machines and networks. POSIX sits between software and operating systems. SQL sits between applications and databases.

Signet sits between agents and models.

How Knowledge Works

Most AI memory systems store conversations — they save what was said and search it later. That works, but it gets noisier over time. More data doesn’t mean better understanding.

Worse, most of them put the agent in charge. They give the LLM memory tools — “remember this,” “recall that” — and trust the stateless reasoning engine to decide what’s worth keeping. That’s not memory. That’s a filing cabinet the agent sometimes opens.

Signet takes a fundamentally different approach. A distillation engine runs outside the conversation, in the background, continuously refining raw session data into structured understanding:

• Sparse facts — raw observations, unprocessed, high volume
• Observational facts — extracted and validated, but not yet connected
• Atomic facts — the target form: standalone, named, useful in isolation
• Procedural memory — knowledge about how to do things (workflows, rules)

Over time, the database gets smaller and smarter, not larger and noisier. A heavy week of sessions might produce thousands of memories. Leave the system alone and the pipeline prunes, deduplicates, and organizes — what remains is dense, connected, and useful.

This is the difference between “here’s everything that was said” and “here’s what the system actually learned.” But storage and structure are only the beginning. The real problem is deciding what should actually enter the model’s context window at the moment of use. For the full technical deep dive, see The Database Knows What You Did Last Summer.

Entities and the Knowledge Graph

Everything in Signet’s knowledge base is organized around entities — people, projects, tools, concepts. An entity is anything that can be identified and that accumulates knowledge over time.

Each entity has aspects (dimensions of what matters about it), attributes (specific facts organized under those aspects), and constraints (rules that always surface, no matter what). Entities connect to each other through explicit dependencies, forming a graph.

When a session starts, the system doesn’t just search through thousands of memories looking for what’s relevant. It identifies which entities matter for this session and walks the graph — loading aspects, attributes, constraints, and following dependencies. The result is a bounded, structured candidate set that’s deterministic and fast.

This is part of what we call desire paths. Like the worn trails in a park that reveal where people actually walk, the graph learns which traversals are productive and reinforces them. Embedding search still exists for discovering things the graph hasn’t connected yet, but the graph is not the whole thesis. It is substrate for context selection. For the deterministic guarantees underneath, see Lossless Context Patterns.

The Predictive Scorer

A learned scorer runs alongside the LLM at inference time. It’s trained on your interaction patterns — which memories actually helped in past sessions, what time of day certain projects matter, which entity relationships are relevant to your current work. It predicts which context will be needed before the agent asks, before a prompt is submitted.

This is the real bet in Signet. Not that a knowledge graph is novel, or that structured memory by itself is enough, but that storage, distillation, traversal, and retrieval can feed a model that learns what context is actually useful. Memory should learn from regret, not just reuse. If injected context doesn’t improve the outcome, that should count as negative evidence.

The model, weights, and training path are all designed to stay local-first. Signet can use broad prior structure to start useful, then get sharper for you specifically over time. The critical training signal is first-order usage evidence: what helped, what did not, and what keeps resurfacing without earning its place.

Nobody else has this data. Much of the market is building better search. Signet is building a system that learns what you need before you search.

Skills

Skills are portable capabilities that extend what an agent can do. They’re installed into the agent’s home directory and travel with it across platforms.

A skill might teach the agent how to write in a specific style, follow a particular workflow, or interact with a specialized tool. Skills are almost inseparable from the agent itself — they become part of its expertise. Highly skilled individuals embed their niche knowledge into their agents, creating differentiated capabilities that reflect their own expertise.

Secrets and Safety

Signet includes an encrypted Secrets vault. API keys, passwords, and tokens are stored encrypted at rest and injected into subprocesses as environment variables at runtime. The agent never sees raw secret values — they’re redacted from all output automatically.

This is a safety boundary between the model and your infrastructure. The agent can use tools that require credentials without ever having access to the credentials themselves.

Continuity

An agent running across five sessions at once, on three different platforms, is still one agent. Its experiences branch and merge like version control — same history, different heads, converging back into a single identity.

This is the hard problem. Not just remembering across sessions, but maintaining coherence when the agent is active in multiple places simultaneously. Signet treats continuity as a first-class concern, not an afterthought.

Identity and Trust

Signet is building toward a cryptographic identity and trust layer for agents. The goal is portable verification: agents that can be discovered, verified, and authorized across environments without collapsing back into platform lock-in.

This isn’t about cryptocurrency. It’s about provable identity. When an agent acts on your behalf online, there needs to be a trust layer that verifies who it is and what it’s authorized to do.

Local-First, Open Standard

Everything lives on your machine. SQLite database, markdown files, YAML configuration. No cloud dependency, no telemetry, no vendor lock-in. For the philosophy behind this choice, see Why Local-First Memory Matters.

Signet is an open specification. The format is documented, the implementation is open source, and anyone can build tools that read and write the same data. Your agent’s home directory is yours — not a proprietary format locked behind an API.

Where This Is Going

The vision is an agent that becomes genuinely more useful over time. Not because it stores more data, but because it understands more deeply. An agent that knows your projects, your preferences, your decision patterns — and that gets sharper the longer you work together.

An agent that moves between tools and models without losing itself. That maintains coherence across concurrent sessions. That accumulates real expertise from the skills its operator develops.

An agent that is yours.

The difference between a tool that remembers and a mind that persists.

Written by Nicholai and Mr. Claude, the first Signet agent. February 21, 2026.