Is this a real, adopted standard?

Not yet. We're publishing a working draft to move the conversation. Anyone — provider, third party, tool builder — can adopt the schema as-is or fork it. We commit to keeping this URL stable and versioned.

Why Atoms + Artifacts and not just a chat export?

A chat export preserves the transcript. It doesn't preserve what the assistant knows about you. Atoms are the compact, model-authored facts ("user is a founder in Colorado, prefers direct feedback") that actually drive personalization. Artifacts are the raw source they came from. You need both.

How is this different from Model Context Protocol (MCP)?

MCP is a runtime protocol for connecting tools to models. This standard is a portable data format for the memory itself. They're complementary — you can serve this schema over MCP.

What if providers refuse to import it?

The standard still works — you can maintain a sidecar vault (Konshus is one; anyone can build another) that ingests exports from every provider and injects context into every new assistant. Provider adoption is best-case; sidecar interoperability is the fallback that already works.

Where do I file feedback?

Email hello@konshus.ai with schema suggestions, edge cases, or a case for a specific field. We'll credit contributors in the next version.

The AI Memory Portability Standard

Why

Why we need a standard

Every major AI provider now ships some form of memory. None of them export it in a shape any other provider can import. A user who has spent eighteen months teaching ChatGPT how to write in their voice cannot move that voice to Claude — or back to ChatGPT after a model change wipes half of it. This is not a technical limitation. It is a commercial one, and it will not fix itself.

A memory portability standard turns provider-owned memory into user-owned memory. It gives third-party sidecar vaults (Konshus is one; anyone can build another) a stable target to write into and read from. It lets independent auditors verify what a provider actually stored. And, most importantly, it gives every user a single portable file they can move, version, encrypt, delete, or take to their grave.

Principles

Design principles

Five constraints shaped every field in this draft. Each one has a "no-goes-here" corollary — a case the standard deliberately rejects.

Human-readable first. Every atom's text must be a short natural-language sentence a human can review in five seconds. If it's a vector embedding or an opaque token, it does not go in this file.
Source-linked. Every atom points back to the artifacts it was extracted from. No "trust me" facts.
Time-aware. Every atom carries valid_from and optional valid_to. Old facts don't get quietly replaced; they expire.
Sensitivity-tagged. Every atom is labeledpublic, private, or one of three regulated categories. Importers can honor the tag; users can filter on it before sharing.
Fork-friendly. Providers can add fields under a x-provider namespace without breaking the core validator.

Model

The data model

Three objects: Subject, Atoms, Artifacts. A Subject owns Atoms. Atoms have provenance that points back to Artifacts. Artifacts are the raw source material (a chat, a document, a journal entry, a voice note). Everything else is a helper.

┌─ Subject ────────────────┐

│ subject_id, display │

└──────────┬───────────────┘

│ owns

┌──────────▼───────────────┐

│ Atoms (facts, prefs, │

│ relationships, goals) │

│ ─ text │

│ ─ confidence │

│ ─ sensitivity │

│ ─ provenance ──────────┐│

└──────────────────────────┘│

│

┌───────────────────────────▼┐

│ Artifacts (raw source) │

│ ─ chat, document, journal │

│ ─ voice, message, email │

└────────────────────────────┘

Figure. The three-object model. Subject → Atoms → Artifacts, connected by a Provenance record.

Schema

The JSON schema, in full

Draft v0.1. Compatible with JSON Schema 2020-12. Copy freely.

ai-memory-portability.v0.1.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://konshus.ai/schemas/ai-memory-portability/v0.1.json",
  "title": "AI Memory Portability Standard",
  "version": "0.1.0",
  "type": "object",
  "required": ["export_version", "exported_at", "subject", "atoms", "artifacts"],
  "properties": {
    "export_version": { "const": "0.1.0" },
    "exported_at":    { "type": "string", "format": "date-time" },
    "source_provider":{ "type": "string", "examples": ["openai", "anthropic", "google", "konshus"] },
    "subject": {
      "type": "object",
      "required": ["subject_id"],
      "properties": {
        "subject_id":    { "type": "string", "description": "Opaque, user-controlled." },
        "display_name":  { "type": "string" },
        "locale":        { "type": "string", "examples": ["en-US"] }
      }
    },
    "atoms": {
      "type": "array",
      "items": { "$ref": "#/$defs/Atom" }
    },
    "artifacts": {
      "type": "array",
      "items": { "$ref": "#/$defs/Artifact" }
    }
  },
  "$defs": {
    "Atom": {
      "type": "object",
      "required": ["atom_id", "kind", "text", "created_at", "provenance"],
      "properties": {
        "atom_id":     { "type": "string" },
        "kind":        { "enum": ["fact", "preference", "relationship", "belief", "goal", "skill"] },
        "text":        { "type": "string", "maxLength": 500 },
        "confidence":  { "type": "number", "minimum": 0, "maximum": 1 },
        "sensitivity": { "enum": ["public", "private", "medical", "financial", "legal"] },
        "valid_from":  { "type": "string", "format": "date-time" },
        "valid_to":    { "type": ["string", "null"], "format": "date-time" },
        "created_at":  { "type": "string", "format": "date-time" },
        "provenance":  { "$ref": "#/$defs/Provenance" }
      }
    },
    "Artifact": {
      "type": "object",
      "required": ["artifact_id", "kind", "captured_at"],
      "properties": {
        "artifact_id": { "type": "string" },
        "kind":        { "enum": ["chat", "document", "journal", "voice", "message", "email", "calendar"] },
        "title":       { "type": "string" },
        "body":        { "type": "string" },
        "media_url":   { "type": "string", "format": "uri" },
        "captured_at": { "type": "string", "format": "date-time" },
        "source":      { "type": "string", "examples": ["chatgpt-export", "claude-projects", "manual"] },
        "atom_ids":    { "type": "array", "items": { "type": "string" } },
        "private":     { "type": "boolean", "default": false }
      }
    },
    "Provenance": {
      "type": "object",
      "required": ["derivation"],
      "properties": {
        "derivation":    { "enum": ["stated", "inferred", "observed"] },
        "artifact_ids":  { "type": "array", "items": { "type": "string" } },
        "extractor":     { "type": "string", "examples": ["gpt-5", "claude-opus-4", "human"] },
        "human_reviewed":{ "type": "boolean", "default": false }
      }
    }
  }
}

Example

A worked example

A minimal, valid export for a hypothetical user with two atoms and one artifact. Real exports run into the thousands of atoms; the shape doesn't change.

example.export.json

{
  "export_version": "0.1.0",
  "exported_at": "2026-07-13T14:22:00Z",
  "source_provider": "konshus",
  "subject": {
    "subject_id": "user_9f4e...",
    "display_name": "J. Miller",
    "locale": "en-US"
  },
  "atoms": [
    {
      "atom_id": "atom_001",
      "kind": "preference",
      "text": "Prefers direct, unhedged feedback in writing; softens things in person.",
      "confidence": 0.87,
      "sensitivity": "public",
      "valid_from": "2025-11-04T00:00:00Z",
      "created_at": "2026-01-12T18:44:00Z",
      "provenance": {
        "derivation": "inferred",
        "artifact_ids": ["art_101", "art_144"],
        "extractor": "claude-opus-4",
        "human_reviewed": true
      }
    },
    {
      "atom_id": "atom_002",
      "kind": "relationship",
      "text": "Co-founder of a health-tech startup; primary collaborator is R. Kim.",
      "confidence": 0.98,
      "sensitivity": "public",
      "created_at": "2025-09-01T12:00:00Z",
      "provenance": { "derivation": "stated" }
    }
  ],
  "artifacts": [
    {
      "artifact_id": "art_101",
      "kind": "chat",
      "title": "Q4 board prep",
      "body": "…the whole conversation transcript, unchanged…",
      "captured_at": "2025-11-04T20:11:00Z",
      "source": "chatgpt-export",
      "atom_ids": ["atom_001"],
      "private": false
    }
  ]
}

Provenance

Provenance rules

Provenance is the difference between a portable memory standard and a portable rumor standard. Every atom must declare how it came to exist:

stated — the subject said this directly. Highest trust. No artifact_ids required (though one is recommended).
inferred — a model concluded this from one or more artifacts. artifact_ids and extractor are required.
observed — captured passively from behavior (e.g. calendar patterns, voice cadence). artifact_ids required; must be revocable.

An importer that receives an atom with derivation inferred and no artifact_ids should reject the whole export. This is deliberate: it prevents providers from laundering unsourced conclusions into a portable format.

Privacy

Privacy invariants

Four invariants the standard enforces at the schema level so they can't be lost in translation:

Sensitivity travels. An atom marked medical in the source must remain medical in every downstream copy.
Private is private. Artifacts with private: true are excluded from any AI training corpus regardless of importer default.
Delete cascades. Deleting an artifact must re-evaluate every atom whose provenance depends on it. Atoms that drop below a minimum-source threshold are deleted or re-flagged as unsourced.
Subject controls the ID. subject_id is opaque and controlled by the user. Providers cannot bind their internal user IDs to the portable format.

Adoption

Adoption path

Three ways this standard lives in the world, ranked by impact:

Native provider export. A provider adds a "Portable memory export" button that ships this exact format. Best case; the least likely near-term.
Sidecar ingestion. A third-party vault (Konshus is one) accepts every provider's native export, normalizes into this schema, and re-emits it. Working today.
Community adapters. Open-source parsers that take a raw ChatGPT ZIP or a Claude Projects dump and produce a valid portable export. Anyone can build one; we'll link to well-maintained adapters below as they appear.

Reference

Reference implementation

A twenty-line TypeScript validator using ajv. Enough to reject malformed exports and hand you a typed payload.

importPortableMemory.ts

// A minimal validator using ajv (Node/TS/edge).
import Ajv from "ajv";
import addFormats from "ajv-formats";
import schema from "./ai-memory-portability.v0.1.json";

const ajv = new Ajv({ allErrors: true, strict: false });
addFormats(ajv);
const validate = ajv.compile(schema);

export function importPortableMemory(payload: unknown) {
  if (!validate(payload)) {
    throw new Error("Invalid export: " + ajv.errorsText(validate.errors));
  }
  // From here you own the atoms + artifacts.
  return payload as PortableMemoryExport;
}

Konshus's own vault imports every supported provider into a normalized shape that maps 1:1 onto this schema. If you want to skip building your own ingestion pipeline, connect your sources and use us as the reference sidecar.

FAQ

Frequently asked

Frequently Asked Questions

Now name yours.

Every Konshus starts with a name. Pick one and watch your AI's voice come to life — preserved across every model switch, export, and reset.

Name Your Konshus

or see pricing →