DOCUMENTATION

The sovereign knowledge layer for artificial intelligence.

VISION

ChainMemory is not a memory tool. It is a sovereign knowledge layer for AI systems.

Every AI model today suffers from the same fundamental limitation: when a conversation ends, everything learned disappears. Context is lost. Decisions are forgotten. Progress resets to zero. ChainMemory exists to solve this permanently.

The memories you save are the mechanism. The Project State — a structured, versioned, consolidated view of your project's knowledge — is the product. The blockchain is the proof. And interoperability between any AI model is the consequence.

What ChainMemory Enables

• Portable memory across models — Your knowledge works with ChatGPT today, Claude tomorrow, and any future model. No vendor lock-in, ever.
• Verifiable continuity — Every project state is anchored on-chain with a cryptographic proof. You can demonstrate that a decision existed at a specific moment in time.
• Decision audit trail — Every decision traces back to the conversations that produced it. Full provenance, full accountability.
• Persistent identity for AI workflows — Your AI assistant doesn't start from zero each session. It inherits the accumulated knowledge of every previous interaction.
• Sovereign knowledge — You own your data. Not OpenAI, not Anthropic, not Google. Your memories live in your account, anchored to a public blockchain you can verify independently.

WHAT IS CHAINMEMORY

ChainMemory is a platform for persistent, portable, and verifiable memory for artificial intelligence. Every important conversation, every decision, every project context is saved as an individual memory, linked to a project, and anchored on a sovereign blockchain.

Your AI forgets every time you close the tab. ChainMemory solves that. It works with ChatGPT, Claude, Gemini, Copilot, Perplexity and any model that supports MCP or API.

QUICKSTART

Save your first memory in under 2 minutes.

ARCHITECTURE

ChainMemory has a 3-layer architecture:

Layer 1: Capture

The Chrome extension, MCP server, or direct API calls capture content from AI conversations. Content is processed, tagged, and linked to a project.

Layer 2: Storage & Consolidation

Each memory is stored in the episodic database with its SHA-256 hash. The Consolidation Engine analyzes memories with a local LLM and extracts structured operations: decisions, milestones, risks, tech stack, dependencies.

Layer 3: On-Chain Verification

The consolidated state of each project is periodically anchored on the ChainMemory blockchain (Chain ID 202604). The state hash is recorded in the ProjectStateAnchor contract, creating an immutable proof that this state existed at that moment.

Pipeline
AI Conversation
      |
  Extension / MCP / API
      |
  Memory (SHA-256 hash)
      |
  Consolidation Engine (phi3:mini via Ollama)
      |
  Project State (decisions, milestones, risks, stack)
      |
  Anchor on-chain (tx hash + block number)
      |
  Public verification (/v1/project/:name/state/anchor)

HOW CHAINMEMORY COMPARES

ChainMemory operates in the emerging space of AI memory infrastructure. Here's how it compares to existing solutions:

CONCEPTS

The Event-Sourcing Model

ChainMemory follows an event-sourcing architecture. Understanding this pattern is key to understanding the entire system.

In traditional systems, you store the current state and overwrite it on each change. In event-sourcing, you store every change as an immutable event, and the current state is derived by replaying those events.

In ChainMemory:

• Memories are events — Each memory is an immutable record of something that happened: a decision was made, a risk was identified, a technology was chosen, a milestone was reached.
• Project State is a materialized view — The Consolidation Engine processes all memory-events and produces a structured snapshot: the Project State. This is not stored directly — it's computed from the event log.
• The blockchain is the timestamp authority — When a Project State is anchored on-chain, the blockchain certifies that this specific materialized view existed at that exact block height.

Pattern
Memory #1 (event) ─┐
Memory #2 (event) ─┤
Memory #3 (event) ─┼──→ Consolidation Engine ──→ Project State v1 ──→ Anchor (block 120000)
Memory #4 (event) ─┤
Memory #5 (event) ─┘

Memory #6 (event) ─┐
Memory #7 (event) ─┼──→ Consolidation Engine ──→ Project State v2 ──→ Anchor (block 123539)
Memory #8 (event) ─┘

This means you can always reconstruct any version of the Project State by replaying memories up to that point. The event log is the source of truth. The state is a convenience layer. The anchor is the proof.

What is a Memory

A memory is the fundamental unit of ChainMemory. It is a fragment of information extracted from an AI conversation that is considered valuable for the project's future.

Each memory contains:

• Content — The text of the conversation or note
• Hash — SHA-256 of the content, immutable
• Project — Which project it belongs to
• Tags — Classification (decision, bug, architecture, idea)
• Number — Sequential within your account (#1, #2...)
• Source — Where it was saved from (extension, MCP, API)
• Timestamp — Exact moment of creation

Projects

A project groups related memories. Each project has its own timeline, consolidated state, and independent on-chain anchor.

Example projects: my-saas, ml-thesis, chainmemory, mobile-app.

Project State

The Project State is the output of the Consolidation Engine: a local LLM (phi3:mini via Ollama) analyzes all project memories and extracts structured information.

The state includes 6 categories:

• context — Summary and project goals
• decisions — Decisions made (with status: active/superseded/evaluating)
• milestones — Project milestones (completed and pending)
• risks — Identified risks with severity
• stack — Technologies and tools
• dependencies — External relationships

The state is incremental: each consolidation starts from the previous state and applies only new operations. The version chain (v1 → v2 → v3) maintains integrity via hash chain.

Evidence Chain

Every decision, milestone, and risk in the Project State carries an evidence field — an array of memory references that justify its existence.

JSON
{
  "id": "d001",
  "title": "Use Clique PoA consensus",
  "statement": "Sovereign blockchain uses Proof of Authority for fast, low-cost anchoring",
  "status": "active",
  "evidence": ["#12", "#45", "#67"]
}

This creates a full provenance chain:

• Decision d001 exists because memories #12, #45, and #67 support it
• Each memory has a SHA-256 hash proving its content hasn't changed
• The Project State containing this decision has a state_hash anchored on-chain
• The on-chain anchor has a tx_hash and block number proving when it was registered

From a single decision, you can trace the full path: decision → supporting memories → content hashes → state hash → on-chain proof. This is what makes ChainMemory decisions auditable and tamper-proof.

Conflict Resolution

When two memories contain contradictory information, the Consolidation Engine applies a deterministic resolution strategy:

Temporal precedence

The most recent memory takes priority. If Memory #20 says "We'll use PostgreSQL" and Memory #40 says "Switching to ClickHouse", the engine marks the PostgreSQL decision as superseded and creates a new active decision for ClickHouse.

Explicit supersession

The engine detects language patterns indicating a change of direction: "instead of", "replacing", "we decided to switch", "no longer using". When detected, the previous decision is explicitly marked as superseded with a reference to the new one.

Status lifecycle

Every decision follows this lifecycle:

Status flow
active ──→ superseded    (replaced by a newer decision)
active ──→ evaluating    (under review, not yet confirmed)
evaluating ──→ active    (confirmed after evaluation)
evaluating ──→ rejected  (discarded)

Evidence accumulation

When multiple memories reinforce the same decision, the engine adds them to the evidence array rather than creating duplicates. A decision with evidence from 5 memories is stronger than one with a single reference.

State Governance

The Project State lifecycle is governed by clear rules:

Who can consolidate?

Only the project owner (the account that created the project) can trigger a consolidation. This ensures that the structured knowledge extraction is always controlled by the data owner.

When does consolidation happen?

Consolidation can be triggered in two ways:

• Manual — Via the MCP tool chainmemory_seal, the API, or the extension's Project Brain view
• Automatic — After a configurable number of new memories (default: every 10 new memories)

Can it be reverted?

Each consolidation creates a new version (v1, v2, v3...). Previous versions remain accessible. You cannot delete a version, but you can always consolidate again to produce a corrected state. The version chain is append-only.

Snapshots

Every Project State version is a snapshot. The combination of version number + state_hash + on-chain anchor creates a verifiable checkpoint. You can fetch any historical version via GET /v1/project/:name/state?version=2.

Hash & Verification

Each memory generates a SHA-256 hash of its content. This hash is the unique, immutable fingerprint of that memory. Content cannot be modified without changing the hash.

The state hash is a hash of the complete consolidated state (all decisions, milestones, risks, etc.). This state hash is anchored on the blockchain via a transaction on the ProjectStateAnchor contract.

Public verification

Verification in ChainMemory is public and permissionless. Anyone can:

1. Call GET /v1/project/:name/state/anchor (no API key required)
2. Get the state_hash and the tx_hash of the transaction
3. Verify on the explorer that the transaction exists
4. Read the contract directly on the blockchain to confirm the hash matches

This proves the project state existed exactly as described at the time of anchoring. It cannot be falsified retroactively.

Privacy Model

A common concern with blockchain-based systems is data exposure. ChainMemory addresses this with a strict separation:

What is stored where

The on-chain record contains only: project identifier (hashed), state version number, state hash, and timestamp. From a blockchain transaction, it is impossible to reconstruct the content of any memory or the details of any decision.

This design means ChainMemory can provide cryptographic verification without compromising privacy. The blockchain proves that a state existed, not what it contained.

CHROME EXTENSION

Installation

1. Go to the Chrome Web Store
2. Click "Add to Chrome"
3. The ChainMemory icon appears in the extensions bar
4. Click the icon and create your account or sign in
5. Select or create a project

Save Memories

From any supported AI chat, the extension automatically detects the active conversation. You have two ways to save:

Floating button

A gold button appears in the corner of the chat. One click extracts the conversation content, processes it, and saves it as a memory.

Extension popup

Click the ChainMemory icon in the browser bar. Select the target project, add optional tags, and confirm.

Each saved memory receives:

• SHA-256 hash unique to the content
• Sequential number within your account (#1, #2, #3...)
• Tags for organization (decision, architecture, bug, etc.)
• Link to the active project
• Timestamp of the moment of saving

Inject Context

The most powerful feature: before starting a new conversation with any AI, ChainMemory can automatically inject the relevant context from your previous memories.

This means your new conversation starts with the accumulated knowledge of previous conversations. Your AI knows what you decided, what technologies you use, what your priorities are.

How it works

1. Open a new chat on any supported platform
2. The extension detects the text field
3. Select the memories or project state to inject
4. Context is automatically inserted as the first message

Project Brain

Project Brain is the consolidated view of your project. The Consolidation Engine analyzes all your memories and extracts:

• Decisions — What was decided and why (status: active, superseded, evaluating)
• Milestones — Completed and pending achievements with dates
• Risks — Identified threats with severity and status
• Tech stack — Project tools and technologies
• Dependencies — External relationships
• Context — Executive summary of the project

This state has a verifiable fingerprint anchored on-chain. You can prove that your project had exactly this state at a given moment.

Supported Platforms

The extension works with any web-based AI chat:

• ChatGPT (chat.openai.com)
• Claude (claude.ai)
• Gemini (gemini.google.com)
• Perplexity (perplexity.ai)
• Copilot (copilot.microsoft.com)

If the platform has a text field and displays conversations, ChainMemory can capture the content.

MCP SERVER

Configuration

The MCP server enables Claude Desktop, Cursor, and other compatible tools to access ChainMemory as a native tool.

Installation

Add this configuration to your claude_desktop_config.json:

JSON
{
  "mcpServers": {
    "chainmemory": {
      "command": "npx",
      "args": ["-y", "@chainmemory/mcp"],
      "env": {
        "CHAINMEMORY_API_KEY": "your-api-key"
      }
    }
  }
}

Available Tools

Once configured, your AI has access to these tools:

Workflow

The typical MCP workflow:

REST API

Authentication

All API calls require authentication via API Key in the header:

HTTP
Authorization: Bearer your-api-key

Base URL: https://api.chainmemory.ai/v1

Memories

bash
curl -X POST https://api.chainmemory.ai/v1/memories \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Decided to use PostgreSQL instead of MongoDB",
    "project": "my-project",
    "tags": ["decision", "architecture"],
    "source": "manual"
  }'

javascript
const res = await fetch('https://api.chainmemory.ai/v1/memories', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer your-api-key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    content: 'Decided to use PostgreSQL instead of MongoDB',
    project: 'my-project',
    tags: ['decision', 'architecture'],
    source: 'api'
  })
});
const memory = await res.json();
// { id: 207, hash: '0x4f2a...', memory_number: 42 }

python
import requests

res = requests.post(
    'https://api.chainmemory.ai/v1/memories',
    headers={'Authorization': 'Bearer your-api-key'},
    json={
        'content': 'Decided to use PostgreSQL instead of MongoDB',
        'project': 'my-project',
        'tags': ['decision', 'architecture'],
        'source': 'api'
    }
)
memory = res.json()
# {'id': 207, 'hash': '0x4f2a...', 'memory_number': 42}

Parameters

Projects

Response
{
  "project": "chainmemory",
  "version": 3,
  "state": {
    "context": { "summary": "...", "goals": [...] },
    "decisions": [
      {
        "id": "d001",
        "title": "Use Clique PoA",
        "statement": "PoA consensus for sovereign blockchain",
        "status": "active",
        "evidence": ["#12", "#45"]
      }
    ],
    "milestones": [...],
    "risks": [...],
    "stack": [...]
  },
  "state_hash": "a7b3c9f2...",
  "anchor": {
    "status": "anchored",
    "tx_hash": "0xce55a800...",
    "block_number": 123539
  }
}

Injection

Verification

Response
{
  "project": "chainmemory",
  "projectId": "0x77f7d980...",
  "version": 3,
  "state_hash": "a7b3c9f2...",
  "anchor": {
    "status": "anchored",
    "tx_hash": "0xce55a800a2a4e30b...",
    "block_number": 123539,
    "contract": "0xa7A8BA51950255b3e223a6745597C67009Fe7875"
  }
}

Error Codes

NETWORK

Network Data

Deployed Contracts

AIC Token is the native currency of the network (not an ERC-20 contract). It is used to pay for transaction gas when anchoring states and registering memories.

Connect MetaMask

To add ChainMemory to MetaMask:

1. Go to chainmemory.ai/network
2. Click "Add ChainMemory to MetaMask"
3. Confirm in MetaMask

Or add it manually with the network data from the table above.

Faucet

The faucet delivers free AIC so you can interact with the blockchain:

• URL: faucet.chainmemory.ai
• Amount: 1 AIC per claim
• Cooldown: 72 hours between claims
• Requirement: Solve a simple challenge (anti-bot)

AUDITING GUIDE

One of ChainMemory's most powerful capabilities is enabling verifiable audits of AI-assisted project decisions — without exposing private conversation content.

Two Levels of Audit

Level 1 — External audit (no owner access)

Anyone can verify that a project state was anchored at a specific point in time, without seeing what it contains. This is like seeing a notarized seal — you know it exists, you don't know what's inside.

What an external auditor sees (public, on-chain):

Level 1 — Public endpoint
GET /v1/project/nova-logistics/state/anchor

Response:
{
  "project": "nova-logistics",
  "projectId": "0x77f7d980...",     // hashed — original name not revealed
  "version": 5,
  "state_hash": "a7b3c9f2e1...",   // proves state existed, reveals nothing about content
  "anchor": {
    "status": "anchored",
    "tx_hash": "0xce55a800...",
    "block_number": 125000,
    "contract": "0xa7A8BA51...e7875"
  }
}

Level 2 — Selective disclosure audit (owner shares data)

The project owner chooses what to share with the auditor. The auditor then verifies the shared data against the on-chain proof. This is the powerful audit: you prove the data is authentic without an intermediary.

The owner controls exactly what gets disclosed:

Step-by-Step Audit Process

Example: NovaTech, a startup building a logistics SaaS. After 4 months using ChatGPT and Claude alternately, the CTO needs to demonstrate project traceability to investors.

bash
curl -H "Authorization: Bearer cto-api-key" \
  https://api.chainmemory.ai/v1/project/nova-logistics/state
    

bash
cat state.json | sha256sum
# a7b3c9f2e1d4...
    

bash
curl https://api.chainmemory.ai/v1/project/nova-logistics/state/anchor
# Returns: state_hash: "a7b3c9f2e1d4..."
    

Privacy Guarantees During Audit

The critical guarantee: the owner always controls disclosure.

• Investors see decisions and milestones — not the raw AI conversations that produced them
• The blockchain proves authenticity without revealing content
• Memory text (actual conversation content) is only visible if the owner explicitly exports it
• The on-chain record contains only hashes — even if the blockchain is public, your project knowledge remains private
• No third party, including ChainMemory itself, can force disclosure of memory content

WHAT CHAINMEMORY PREVENTS

Understanding what ChainMemory protects against is as important as understanding what it does.

Context loss

Every AI conversation today is ephemeral. Close the tab and everything discussed — decisions, architecture choices, research findings — vanishes. ChainMemory captures these as permanent, retrievable memories. Your next session starts where the last one ended.

Vendor lock-in

If your project knowledge exists only inside ChatGPT's conversation history, you're locked in. ChainMemory stores knowledge independently of any AI provider. Switch from ChatGPT to Claude to Gemini without losing a single decision or context.

Retroactive manipulation

Without cryptographic proof, anyone could claim "we decided X" when the actual decision was Y. ChainMemory's on-chain anchoring creates a tamper-proof record. The state hash at block 123539 proves exactly what the project state was at that moment. It cannot be altered after the fact.

Knowledge fragmentation

Teams using AI end up with critical knowledge scattered across dozens of disconnected conversations, in different tools, with different models. ChainMemory consolidates everything into a single, structured Project State — regardless of which AI or tool produced the original conversation.

Single-AI dependency

When one AI provider goes down, changes its API, or deprecates a feature, projects relying solely on that provider lose continuity. ChainMemory's cross-model architecture ensures your accumulated knowledge is accessible from any compatible AI system.

Invisible decision drift

In long-running projects, decisions evolve over months. Without a system that tracks what changed, when, and why, teams lose track of their own reasoning. The Consolidation Engine's decision lifecycle (active → superseded) with evidence chains makes every evolution traceable.

FAQ

General

Is ChainMemory free?

Yes. The Faucet plan is free and includes memory storage, context injection, and Project Brain. The faucet gives you free AIC to interact with the blockchain.

Are my memories private?

Yes. Your memories are only accessible with your API key. The only public data are the on-chain hashes (which reveal nothing about content) and the verification endpoint (which exposes only metadata, never content).

What if the AI generated incorrect content in a memory?

Memories capture what was said in the conversation. If the AI generated incorrect information and you saved it, that memory will reflect the error. You can archive incorrect memories and the Consolidation Engine will prioritize the most recent ones.

Can I use ChainMemory with local models?

Yes, via the REST API. Any application that makes HTTP calls can save and retrieve memories. You can also configure the MCP server with local models via Ollama.

What is the Consolidation Engine?

It's a pipeline that analyzes your memories using a local LLM (phi3:mini) and extracts structured information: decisions, milestones, risks, stack. The result is the Project State, whose hash is anchored on-chain.

What happens if my AI says contradictory things across sessions?

The Consolidation Engine handles contradictions through temporal precedence: newer memories supersede older ones. Superseded decisions remain in the state with a "superseded" status, so you always have the full history. See Conflict Resolution for details.

Can I export my data?

Yes. All your memories and project states are accessible via the REST API. You can fetch them in JSON format and process them however you need.

Limits & Quotas

Changelog

v3.0.9 (June 2026)

• Fix: Project Brain displays decisions and risks correctly (Phase 2 schema)
• Fix: Memory numbering shows user sequential number

v3.0.0 (May 2026)

• Project Brain: consolidated state visualization
• Consolidation Engine: complete pipeline with phi3:mini
• On-chain anchoring of Project State
• Public verification API

v2.0.0 (April 2026)

• MCP Server for Claude Desktop and Cursor
• Automatic context injection
• Support for 5 AI platforms