Remember

A mind that remembers everything.

Persistent memory for AI agents across three tiers. Server-side and durable, so nothing an agent learns is lost to a restart or a cleared browser. The orb behind this page is the memory core: everything it takes in, kept, and recalled on demand.

Get started Read the docs

$docker compose up -d memory

memory types8memory tools4import platforms4

In plain words

What it is, where it lives, when to reach for it

What is it: The memory system inside QuoxCORE where agents store what they learn between sessions.
Where do I use it: On the dashboard's Memory page, and through the quox memory commands in your terminal.
When would I use it: When an agent learns a fact or a decision that later sessions should not have to rediscover.
How do I use it: Run quox memory search "<topic>" in your terminal, or open Memory in the dashboard sidebar.

QuoxCORE is the free, self-hosted platform underneath this. What is QuoxCORE

The problem

Every AI you use today forgets you the moment the tab closes.

Session amnesia means every conversation starts from zero. Nothing is truly learned, so your preferences, your style and your business get re-explained forever. What is remembered sits in a black box you cannot read, correct or audit. And it all lives on someone else's servers.

Live demonstration

Watch a memory survive the session.

Session one learns three things. The session ends and its working context is discarded. Session two starts cold, asks, and the memory comes back with its provenance. That is the whole promise: nothing an agent learns is lost to a restart.

agent · ops assistant memory

session 001 open

nginx runs on nw-web-01 at 10.20.0.101. And I prefer UK spelling in reports.

entity_note nw-web-01 · 10.20.0.101 · runs nginx

memory_save prefers UK spelling · semantic

We are keeping the collector on the v2 API.

memory_save decision: collector stays on v2 · semantic

session 001 closed · context window discarded

session 002 open · fresh browser, empty cache

Which host runs nginx?

memory_search "which host runs nginx"

nw-web-01 · 10.20.0.101 · runs nginxentity · saved in session 001 · vector + BM25 · fused with RRF, k = 60

nginx runs on nw-web-01 at 10.20.0.101. Learned in session 001.

The working set dies with the session, by design. The semantic store and the vector index do not. Session two answers from durable storage, not from a context window, and every save and search along the way is logged to the audit trail.

A fresh browser with an empty cache produces the same mind.
Server-side is the source of truth, always. Memory survives sessions, devices, restarts and cleared caches. It is never a browser-only store, and it is yours to read, export and audit.

Memory types

Eight kinds of memory, one system.

Different information needs different treatment. Everything an agent holds is one of eight typed stores, each with its own rules for recall, confidence and decay.

Episodic what happened

Complete conversation history, preserved and searchable. Pick up where you left off, even months later.

full logs · timestamp index · cross-session continuity

Semantic what is known

Learned facts, preferences, brand guidelines and writing styles, applied automatically to every interaction.

facts · user preferences · business rules

Entity who and what

A knowledge graph of your world: clients, projects, infrastructure, and the relationships between them.

people · systems and services · relationship mapping

Working what is in play

Active context tracking: open tasks, current projects and recent discussions. It always knows what is happening now.

active tasks · open loops · current focus

Core always loaded

Critical context injected into every conversation: user profile, key preferences and essential facts.

always loaded · token-budgeted · per-agent

Style how you sound

Learns how you communicate: tone, vocabulary and formatting habits. Responses feel like they came from you.

tone · vocabulary · response length

Belief how certain

Tracks what your AI knows versus believes versus assumes, so it weighs information correctly.

fact / belief / assumption / hypothesis · confidence 0 to 1 · evidence tracked

Failure what went wrong

Remembers what did not work and why, so the same mistake never happens twice.

12 failure types · severity levels · pattern detection · resolutions reused

Memory as tools

The agent decides what matters.

Unlike passive context windows, QuoxMemory gives the AI explicit tools to manage its own memory. The agent actively decides what is worth remembering, searches for relevant context before answering, and updates information that has gone stale.

This is not just storage, it is memory management. Every save, search and update is logged, so you can read, export and audit exactly what your AI learned and why.

Four tools: memory_save, memory_search, memory_update, entity_note
Every operation logged to the AEE audit trail
SQLite persistence with FTS5 full-text search
Claude-native tool definitions

memory tools · live session

› memory_save "prefers dark mode, runs a Proxmox cluster"
  ✓ saved · semantic · id mem_7f3a · logged to AEE

› entity_note "nw-web-01: 10.20.0.101, runs nginx, prometheus"
  ✓ entity nw-web-01 updated · 2 services linked

› memory_search "what did we decide about the API structure"
  1. decision: collector stays on the v2 API 0.91
     semantic · saved session 001 · vector + BM25
  2. API versioning discussion 0.64
     episodic · thread 118

› memory_update mem_7f3a "server IP moved to .105"
  ✓ updated · previous value superseded · logged to AEE

Hybrid recall

Found by meaning, or by the exact words.

Every search runs twice. Qdrant finds memories by vector similarity, FTS5 finds them by keyword rank, and the two lists are fused, so the right memory surfaces whether the words match exactly or only the meaning does.

query"which host runs nginx"

Qdrant · vector similarityrecall by meaning, embeddings

FTS5 · BM25recall by keyword rank

RRF · k = 60reciprocal rank fusion

resultranked memorieswith provenance

Promotion

Memories earn their place.

Imported and new memories start cold. As access patterns prove them useful they are promoted automatically, and hot memories are always loaded. Stale memories decay, batch review and quality scoring keep the store honest, and you control the rules.

Consolidation

AI-powered memory cleanup.

Included QuoxFlow workflows use Claude to analyse your memory store. They identify duplicates and suggest merges, resolve contradictions by marking the outdated memory as superseded, promote important patterns to core memory, and archive stale information to keep active memory focused.

This is not rule-based cleanup, it is intelligent consolidation. The AI understands context, recognises when information has been superseded, and keeps the memory healthy.

consolidation run · quoxflow workflow · 4 findings

merge"prefers dark mode" duplicates "likes the dark UI"merged

supersede"server IP .101" contradicts "server IP .105"newest kept

promote"contract renews in March" used in 6 sessionscore memory

archive"migration to the v1 API" superseded, unusedarchived

Your richest data source

Terminal sessions feed the memory.

Terminal sessions contain more infrastructure knowledge than any documentation.

01Terminal output flows through

Every command, error and response passes through the memory bridge automatically.

02Entities are extracted

Hosts, IPs, services and containers are detected and stored as structured entities in your knowledge graph.

03AI context gets richer

Next time you ask, the AI already knows your infrastructure. Error resolutions become permanent knowledge.

Pair with QuoxTerminal to enable the full terminal to memory flywheel, or read the terminal memory docs.

Migration

Bring your history.

Do not start from zero. Import conversations from four major AI platforms: years of context, preferences and decisions, extracted and searchable.

Every imported conversation stays browsable in the archive: filter by platform, search across all messages, and open full threads. All those insights buried in old conversations become part of your memory system.

Automatic memory extraction from conversations
Secret detection and redaction on import
Browsable conversation archive with a thread viewer
Deduplication across platforms

ChatGPT.json

Claude.dms / .json

GeminiTakeout / AI Studio

Perplexity.md / .json

export ▸ import ▸ extract memories ▸ browsable archive

Comparison

QuoxMemory against the rest.

How purpose-built memory compares to bolt-on memory.

Feature	ChatGPT memory	QuoxMemory
Conversation memory	Limited context window	Unlimited, persistent
Cross-session recall	Basic (paid plans)	Full episodic and semantic
Entity knowledge graph	None	Full relationship mapping
Memory tools for the AI	None	4 tools, AI-controlled
Consolidation workflows	None	Automated cleanup
Memory management UI	Basic list	Search, edit, delete
Data ownership	OpenAI servers	Self-hosted, your data
Search type	Basic keyword	FTS5 full-text plus vector recall
Conversation import	None	4 platforms (ChatGPT, Claude, Gemini, Perplexity)
Belief tracking	None	Facts vs assumptions vs hypotheses
Failure memory	None	Learn from mistakes, pattern detection

Use cases

Memory for every workflow.

From personal productivity to enterprise agents.

01Client management

“What did Sarah’s company decide about the rebrand?” Remember every client detail, preference and history.

02Infrastructure ops

Know your entire infrastructure: IPs, services, dependencies and past incidents. Never re-explain your setup.

03Knowledge work

Build a second brain. Research findings, decisions and style guidelines, all searchable and all connected.

04AI agents

Give your agents real memory. They learn from interactions and improve over time. No more amnesia.

05Terminal intelligence

QuoxTerminal feeds hosts, errors and session data into memory automatically. Your AI learns your infrastructure from real terminal sessions.

Architecture

Built for production, not prototypes.

SQLite with FTS5 gives full-text search without embedding costs: deterministic, debuggable and fast. Org-level multi-tenant isolation keeps every user's memories separate. And it is self-hosted, so your memories never leave your servers.

AI agentdecides what to keep▸memory APIsave · search · update▸SQLite + FTS5durable, indexed

every operation is written to the AEE audit trail

276test cases

14test files

4agent-facing tools

The memory service ships with its own suite covering the store, archive, quotas, identity, role guards and schema migrations. The figures above are counted directly from the service's test directory.

Part of QuoxMind

The memory layer of a cognitive architecture.

QuoxMemory is one of 12 cognitive implants in the QuoxMind suite, inspired by the hippocampus: the brain region responsible for forming, organising and retrieving memories.

Free tier

Basic storage

Episodic, semantic and entity memory. Keyword search and core memory injection. Ships with QuoxCORE.

Keyword search across memories
Core memory injection, 500-token context budget

Pro tier · $29 one-off

Advanced memory

Vector search, working set memory, truth arbitration, style engine and memory promotion. Part of QuoxMind Pro.

Unlimited learned items and history
4,000-token context budget

Explore all 12 implants →

The three parts

Memory, Brain2 and Mind: how they fit together.

Three separate products that read from the same governed platform. Here is what each one actually does, and where the lines are.

QuoxMemory · this page

The memory layer. Persistent, tiered storage for what an agent has learned: episodic, semantic and entity memory that survives a restart or a cleared browser.

Brain2

The self-feeding graph. Connects to your sources once, then keeps indexing and consolidating them on its own into a governed, cited knowledge graph.

See Brain2 →

QuoxMind

The reasoning layer. Twelve named cognitive implants that perceive, recall, reason and act, with every decision logged as evidence you can replay.

See QuoxMind →

▸How they fit: QuoxMemory holds what is already known, fed by Brain2, which finds and consolidates new sources on its own, while QuoxMind reasons over both to decide what to do next.

Planned

QuoxMemory Server

Run QuoxMemory as a standalone memory service and connect any AI application. Deploy on your own infrastructure with full control over retention, backup and scaling. This is on the roadmap, not shipping yet: today QuoxMemory runs inside QuoxCORE.

standalone deploymentREST API accesscustom retention policiesenterprise SSO

Real output, this instance

One memory store, answering for real.

Not a mockup. Two calls against this dev instance's own memory service, captured tonight. The counts below belong to this one instance, built up from real development sessions on this box: they are not a customer's numbers, and every org gets its own separate store.

memory service · GET /api/memory/stats and /api/memory/search · port 3103

› GET /api/memory/stats
  {
    "memories": { "total": 546, "by_type": {
      "observation": 317, "entity": 219, "fact": 4, "decision": 3, "constraint": 3
    } },
    "core_memories": 5, "relations": 1
  }

› GET /api/memory/search?q=backup&limit=3
  results: 3
  1. observation The backup system currently works with 21 components via a shell script, but restore still has bugs…
  2. observation QuoxTemporal v5 vision includes operational rhythm awareness, deadline tracking relative to similar…
  3. entity The implementation plan is organized into BR-1 through BR-8 phases covering bug fixes, complete back…

Typed memory with a real breakdown, and search that returns typed, scoped results rather than freeform text. These are the store's own row types, not a curated sample: observation carries most of the weight here because most saves on this box come from agent tool calls during real development sessions.

Where it stands

What's proven, what's still beta

The maturity map for the memory subsystem, current as of the latest audit. Only the core store is marked stable; everything built on top of it is beta, shipped end to end but without a live production corpus yet.

Live and proven

The core memory store: CRUD, FTS5 full-text search and quota enforcement, org and user scoped on every route
The stats and search endpoints shown above run on that same stable store, not a separate demo path

Beta and partial

Agent memory tools, memory_save, memory_search, memory_update, entity_note, reachable only by agents whose own tool list includes them
Core-memory injection at chat dispatch: capped to five core memories and five search hits inside a 600-token budget, degrades to no context if the memory service times out
Identity persistence, profile, projects, working set, beliefs, with write-through and fresh-browser hydration
QM-LTM conversation capture and recall: fixed to resolve org-scoped provider keys, off by default behind a flag, verified live on three conversations

Known gaps

Vector and hybrid recall depend on Qdrant, marked Experimental: if its API key is unset the container will not start, and search degrades silently to keyword-only
The knowledge graph is dormant, two entity relations at the last audit, and the conversation archive is empty: the browsable thread viewer has nothing to show yet
QuoxDream session journals are not org or user scoped: every journal write lands under a shared default identity
The standalone quox-memory repository is a stub: no runtime code path reads or writes it as part of this memory system

Install

Ships with QuoxCORE. One command.

The memory service is included in the QuoxCORE compose stack. A standalone repository exists for custom setups and is available to design partners on request.

$docker compose up -d memory

Get started →Read the memory docs

private beta · QuoxMemory ships today inside QuoxCORE · the standalone repository is available to design partners on request

Remember

Give your AI a real memory.

Stop repeating yourself. Start building context that compounds, on your servers, with an audit trail you can read.

Get started Talk to sales

Go deeper

Technical documentation.

Advanced Memory plugin ($99)/Memory docs/Conversation recall/Memory API/Audit trail (AEE)/Terminal memory/QuoxMind suite/QuoxCORE/QuoxTerminal/Architecture