A timeline, not a log
Every event is immutable and time-stamped. Corrections supersede instead of erasing — the old version stays for archaeology. TTL, dedup, and open commitments are first-class.
Your agent's memory is not a list.
It is a universe.
Nous is a self-hosted memory server for AI agents. It stores what your agents think, feel, and do — on an immutable timeline with branches and projected futures.
docker compose --profile app up -dPostgreSQL 18 + pgvector · ONNX models baked in · :8720Works where your agents already live
ClaudeCursorDevinClineOpenClawHermesDeepSeek harnessAny MCP clientClaudeCursorDevinClineOpenClawHermesDeepSeek harnessAny MCP client
Everything a memory should be
Three dimensions, three types
Cognitive for thoughts, somatic for energy and stress — with real Hz when a wearable provides them —, behavioral for actions. Every memory also declares its type — episodic, semantic, or procedural — with emotional valence from −1 to 1 and encoding context. The dashboard's somatic check-in logs your state in one tap.
Search that never leaves the machine
BM25 + pgvector + reciprocal rank fusion + recency decay + a local cross-encoder reranker. A fan-effect pass penalizes near-duplicates so ten results are ten different memories. ONNX models are baked into the image — no external API is ever required.
A memory that sleeps
On its sleep cycle, Nous consolidates: it replays and strengthens salient traces, archives the weak, promotes the essential to the curated tier — and distills clusters of similar episodes into semantic gist events. Every report counts what the replay salvaged from the brink of forgetting. Archiving is never deleting: forgetting is reversible and everything can be restored.
The curated tier, a living MEMORY.md
Memories promoted to curated are immune to decay and archiving — durable truths the system itself selects and maintains. The equivalent of a MEMORY.md that writes itself.
Intentions that wake on their own
Real prospective memory: “in 3d” or “when X happens”. Temporal or event triggers, cancellable and snoozable — and when one fires it arrives with a preparation pack: the related memories already attached. A reminder that brings its context.
Contradictions are signal
When two memories conflict, Nous doesn't pick one: it creates a first-class 'contradicts' edge, visible as a link in the dashboard's brain graph. The tension stays on record, not hidden.
Routine mining
Nous detects recurring behavioral sequences — your deploy rituals, your Monday patterns — and reports them with measured support and confidence. Habits backed by statistics, not hunches.
Workspaces that respect privacy
Personal scope is the default — nothing leaks to the team by accident. Workspace scope is always an explicit act. Roles, invitations, and per-agent API keys.
Bring your history
Importers for gbrain, memlord, and Obsidian preserve timestamps and provenance. Export everything to JSONL whenever you want — it is your data.
Recall reshapes memory
Memories recalled together grow a 'coactiva' edge — fire together, wire together. Every recall opens a labile window where an edit counts as reconsolidation, and negative traces rehearsed in calm slowly lose their charge. Reading is never free — it rewrites.
Working memory, on purpose
Drafts, hypotheses, session context: they live in a volatile buffer that expires without rehearsal — and only promotion happens through repetition. Forgetting in the buffer isn't a bug; it's the feature that keeps the long-term line clean.
It knows what it knows
Every recall carries a confidence score derived from reinforcements, consolidation weight and open contradictions — and candidates below the solidity threshold come back flagged “almost remembered” instead of silence. The tip-of-the-tongue is a first-class signal, not a miss.
Forget on purpose
Directed forgetting marks a memory for accelerated decay — triple the rate, fully reversible, never a silent delete. The healthy way to let something fade without pretending it never happened.
Quarantine untrusted sources
Mark a source unreliable and everything it writes lands in quarantine — indexed, visible, auditable, but invisible to recall until you approve the source. Injection-resistant by design: bad provenance can't contaminate the line.
Reviews at the edge of forgetting
Every recalled memory computes its next optimal review from its own decay curve — the moment right before it would fade. Spaced repetition with no decks to maintain: reading the due list is itself the rehearsal.
It dreams in REM
During sleep, memories that are neither identical nor unrelated — distant but adjacent — get creative 'rem' links. Serendipity as a nightly process: the associations a wakeful mind wouldn't dare.
What happened next
Consecutive memories from the same source link into an episodic chain — each result can answer “and then?”. Temporal neighbors ride along every search, so stories arrive whole, not as fragments.
Abstractions with receipts
When sleep distills episodes into a semantic gist, recall brings the episodes that ground it — every abstraction arrives with its evidence. You can always drill from the summary down to the raw moments.
Salience, honestly computed
Prediction-error rewards the unexpected at write time; epoch primacy and spaced rehearsal stretch half-life; the sleep cycle even suggests its quietest window from your own activity rhythm. Importance is derived, never declared.
Open loops stay loud
A commitment without a closing event gets a salience boost in every recall — the Zeigarnik effect, wired in. Finish the task and the boost releases on its own; the pending weighs more than the resolved until it isn't pending anymore.
Recalling makes rivals forget
Every retrieval weakens the competitors that almost won but didn't — retrieval-induced forgetting — and encoding a near-duplicate occludes the older version it competes with. Both are counted in `debilitados`: the auditable counterpart of `refuerzos`.
Flashbulb encoding
Surprise × emotional intensity writes the trace at 1.5× weight, capped and tagged `flashbulb` for audit. The 'where were you when' memories get the encoding strength biology gives them — and the tag says the engine decided it, not you.
The what outlives the where
Confidence factors the reliability of a memory's source separately from its content — source amnesia, by design. An untrusted provenance discounts the recall even when the fact itself is identical; you remember what, and how much to trust where it came from.
Starts informed, within budget
Session start packs the bootstrap by characters, not by count: guardrails first, then the curated core, open loops and hot facts — until the budget fills, never mid-line. What it can't fit is reported by section, and the whole pack renders as a frozen snapshot for one-time injection that preserves the prefix cache.
Corrections become guardrails
Every 'never do that again' can mature into a censor — a first-class rule that survives sleep cycles and never gets distilled into a gist. Before acting, the agent verifies the action against every censor in force; a blocking censor vetoes it, an advisory one warns and lets it through.
Honesty, measured
Predictions declare their confidence before the outcome exists; resolving them feeds a Brier score and a reliability curve over ten deciles. When the system says '90% sure', you can audit whether 90% of those were actually true — calibration is a metric, not a vibe.
Sessions end with a handoff
Opening a session is a first-class boundary; closing one distills a continuity document — active guardrails, open loops, what was written and the curated core — ready to paste into the next session. Memory that survives the context window, by design.
Proposes, you approve
Turn on write-approval and every agent write lands staged — out of every recall path — until a human approves or discards it. One endpoint for the pending queue, one click to approve all: human-in-the-loop as a feature flag, not a fork.
Privacy has a middle layer
Between allow and block sits scrub: anything leaving for an external provider passes through redaction of tokens, keys and credentials first. External intelligence is still opt-in — but now opt-in no longer means opt-out of safety.
It knows what it doesn't know
Every query can return a gap map alongside the results: coverage, mean confidence, and each concrete hole — dimensions with no evidence, weak evidence, or content that is parametric only. An honest answer is not just 'this is what I have' — it is 'and this is what I'm missing'.
Self-citation has a ceiling
Content asserted from the model's weights — parametric, never observed — is confidence-capped at 0.70 until reality vouches for it. Reinforcements from real use lift the cap; human approval of a staged write lifts it too. The system cannot promote its own guesses to facts.
Confidence, explained
Every recalled memory now carries its epistemic breakdown: evidence, senescence, contradiction penalty, provenance, the ceiling that applied — and the final number. '0.68' becomes '0.68 because the source is trusted, the content is old, and it was never corroborated'.
Fired together, surfaced together
Co-activated edges are finally read, not just written: memories that fired together in past recalls surface as hebbian associates — a short-term potentiation window (~6h) stacked on the durable long-term weight. What was recalled together is remembered together.
The fourth dimension is time
Most memory tools answer “what happened”. Nous keeps the whole structure: what happened, what almost happened, and what could still happen.
The Worldline
the pastYour history is an immutable line of events. Nothing is deleted in place — supersession chains preserve every version, so six months later you can still ask what was true then.
The Cursor
the presentConsciousness is a cursor moving along the structure. “Now” is simply where it points. Search, context, and predictions all resolve from that point.
The Branches
ignored realitiesEvery decision forks reality. Nous stores alternative branches — like git for your timeline — so the paths not taken stay queryable instead of vanishing.
The Projections
the futuresFrom wherever the cursor stands, Nous recomputes up to ten phantom tributaries — probable futures derived from your actual history, not generic guesses.
The Objectives
the destinationsGoals are pinned points on the map. Trajectories measure the distance left and the rate you are covering it — progress you can literally see.
Numbers, not adjectives
- 13ms
- recall p50 — hybrid search over a 10k-event corpus
- 8.5ms
- local embedding p50 — ONNX, zero network
- ~1µs
- per honesty signal — metamemory, tip-of-the-tongue, extinction
- 33µs
- fan-effect pass — ten results become ten different memories
- 0.44ms
- surprise→epoch frontier over the 50-event trajectory
- ×3
- directed-forgetting acceleration vs natural decay
- ~5ms
- p95 per source-trust check, episode chaining or snooze
- ~43µs
- budgeted bootstrap pack — starts informed in microseconds
- ~2µs
- per guardrail verdict — pre-action, on the hot path
- ~0.9ms
- Brier + reliability curve over 1K resolved predictions
- ~3.5µs
- gap-map verdict — every query declares what's missing
- 0.70
- confidence ceiling on uncorroborated parametric claims
- 2.1ms
- hebbian expansion — co-activated neighbors join the recall
- 0
- external calls required — the engine is fully local
Measured on a commodity Windows box. Reproduce: python -m scripts.benchmark_search + benchmark_neuro2 + benchmark_neuro3 + benchmark_neuro4 + benchmark_neuro5 + benchmark_neuro6
Up in four commands
Two ways to run the same engine. Docker ships the whole stack; pipx gives you the global `nous` command on top of your own PostgreSQL.
Docker
the whole stack, one containerClone the repo and enter it
git clone https://github.com/leoquintara/nous.git && cd nousCreate your .env with an API token
cp .env.example .env && echo "NOUS_API_TOKEN=ns_$(openssl rand -hex 32)" >> .envLift PostgreSQL 18 + pgvector + the app
docker compose --profile app up -dConfirm the brain is alive
curl -s localhost:8720/health
MCP over streamable-http and the REST API on :8720, with baked-in ONNX models. The dashboard (commercial layer) is a separate service — with the `nous-dashboard` repo cloned, `--profile dashboard` lifts it on :3000.
pipx
the `nous` command, globalLift just PostgreSQL (or point to yours)
docker compose up -d dbInstall Nous from PyPI (Python 3.11–3.13)
pipx install nous-memoryApply the database migrations
nous db upgradeServe API + MCP
nous serve --transport http
The `nous` command lives in your PATH: serve, doctor, export, import, consolidar, prune. The first boot downloads the ONNX models (~150 MB) once. The dashboard installs separately — it is the commercial layer.
Either way, `nous doctor` diagnoses the environment — database, models, token — before you plug an agent in.
nous doctorHow it compares
The memory layer market in 2026, side by side. Prices from public pages, October 2026.
| Nous | Mem0 | Zep | Letta | Memlord | |
|---|---|---|---|---|---|
| Self-hostable | |||||
| MCP-native | |||||
| Local embeddings — no external API needed | |||||
| Temporal model: branches + projected futures | |||||
| Somatic dimension (body / emotion / Hz) | |||||
| Supersession audit trail + TTL | |||||
| Workspaces, roles & scopes | |||||
| 3D/4D visual dashboard | |||||
| Neurocognitive patterns (sleep-consolidation, prospective, contradictions, routines) | |||||
| License | AGPL + commercial | Apache-2.0 | Apache-2.0 | Apache-2.0 | AGPL + commercial |
| Paid entry point | $10/mo | $19/mo | $125/mo | $20/seat | commercial lic. |
“partial” = a narrower form of the capability (e.g. Zep keeps validity windows on facts — temporal, but not navigable branches).
Measured in production
0
rounds won by Nous (of 6)
gbrain 0memlord 1ties 0
Nous wins on more kinds of real memory
6 benchmark types, 22 random queries built from a real sample of migrated content — exact detail, entities, thematic RAG, temporal, cross-corpus synthesis and latency. Every hit was verified against real content; a system is only scored on corpora it actually contains.
Dates, URLs, percentages and emails buried in messages — the cross-encoder reranker crowns the precise fact where single-pass retrieval returns approximations.
“Who is X” — a technical tie: both systems resolve the canonical card; Nous additionally crosses it with messages, temporal span and links.
Migrations, guardrails, projects by city — Nous covers both corpora with a single intent; each rival only holds half the history.
Full segmented weeks and earliest/latest questions with typed verdicts — `recall` resolves temporal intent, not just semantics.
One question, two corpora: `gbrain` card + `memlord` messages. Nous is the only system that can cover both sides — the rest score partial at best.
The round Nous loses: ~4x slower because every `recall` runs reranker + metamemory + temporal context + verdicts — where the others make a single pass. Optimized with batched rerank + 224-token truncation.
Honesty included: Nous lost the latency round (~10x) and the benchmark exposed a real gap — migrated corpora are invisible from the default workspace (multi-tenant isolation by design): `recall` with an explicit workspace= is the correct way to query them. The full run is persisted in the dashboard `/benchmarks`.
How they combine
A memory travels the whole pipeline
40+ neurocognitive patterns aren't a checklist — they're a system. Every memory passes through five stations and each pattern hooks at its exact point. Watch it live:
› input → cognitive dimension, amplitude 0.8 — the new source waits in quarantine until it earns trust
The names aren't marketing: every chip maps to a pure module in src/core/memoria with its own tests — decay, consolidacion, prospectiva, interferencia, contexto, scripts, tipos, ritmos, retrieval, novedad, trabajo, semanticizacion, diversidad, rem, bootstrap, verificacion, calibracion, handoff, epistemica…
Open core, honestly
The engine — server, MCP, REST API, CLI, memory patterns — is AGPL-3.0. Read it, fork it, self-host it forever — free. The free edition gates itself to 1 user and 3 workspaces; the commercial layer (dashboard and Pro features, licensed via JWT verified locally) lifts that and frees you from AGPL obligations.
AGPL-3.0 — the engine
Free foreverThe whole memory server: 4D timeline, hybrid search, neurocognitive patterns, MCP tools, REST API and CLI. Self-host it, audit it, extend it. The free edition is the real thing — not a demo.
Commercial layer
Dashboard + Pro featuresThe dashboard and Pro capabilities ship as a commercial layer that talks to the engine over the REST API — that network boundary is the legal boundary. It includes the decision advisor: dilemmas evaluated against your 4D worldline, local provider first with an honest fallback when none is available. The license is a JWT verified locally — activated and removed from the dashboard, no CLI needed. Funds the roadmap.
Powered by Nous
Projects already trusting Nous as the memory of their agents. Building with it? Open a showcase issue and yours joins the list.
Pricing that scales with the brain, not the bill
Self-hosted forever for individuals. Licensed when the team grows. No mandatory cloud, no phantom-seat rent — you pay for the commercial layer, not for your data.
Community
For developers who self-host
$0forever
- Full 4D engine — AGPL-3.0
- 1 user · 3 workspaces
- Local ONNX models baked in
- MCP + REST + CLI
- Community support
Indie
Commercial license for solo builders
$10/month
- Everything in Community
- Unlimited users & workspaces
- AGPL exemption
- Decision advisor: dilemmas against your 4D worldline
- Manage your license key from the dashboard — no CLI
- Email support
- Name in release notes
Team
A shared brain for small companies
$26per seat / month
- Everything in Indie
- Roles & invitations
- Workspace-scoped memory
- Priority support
- Migration assistance
Enterprise
Regulated or at scale
Custom
- SSO / SAML roadmap access
- SLA & support windows
- Assisted on-prem deployment
- Influence on the roadmap
Nous Cloud
Zero-ops hosted Nous — early access opens 2027
The license is a JWT verified locally — no phone-home, no mandatory cloud subscription. The engine stays AGPL-3.0: a license exempts you from it and unlocks the commercial layer. Prices in USD, tax included — checkout shows your local currency.
Frequently asked questions
Direct answers, no fine print.
What is Nous?
Nous is a self-hosted memory server for AI agents. It stores what your agents think, feel, and do on an immutable 4D timeline — then consolidates, retrieves, and forgets like a real memory does. It runs as an MCP server with REST and CLI parity.
How is Nous different from a vector database or RAG?
A vector store saves embeddings and returns the top-k most similar. Nous models the lifecycle: memories consolidate during sleep cycles, decay and compete during recall, get reviewed on a spaced schedule, and carry honesty signals — confidence scores, tip-of-the-tongue flags, source trust. Retrieval is one stage of the memory, not the whole thing.
Does my data leave the machine?
No. Embeddings, the cross-encoder reranker, and every decision heuristic run locally — ONNX models are baked into the Docker image, so the server works fully offline. There are zero external API calls in the hot path; there is nowhere for your data to go.
Which agents does Nous work with?
Any MCP-compatible client: Claude, Cursor, Windsurf, Cline, Devin, OpenClaw, Hermes, and DeepSeek harness among them. The same tools are also exposed over REST and a CLI, so custom harnesses integrate without MCP.
Can I trust what the agent remembers — and what it plans?
Three mechanisms close the loop: guardrails turn corrections into rules the agent verifies before acting (blocking rules veto, advisory ones warn); staged writes hold every agent write out of recall until a human approves; and the Brier calibration report measures whether '90% sure' predictions actually came true 90% of the time.
What does it cost?
The engine is free forever under AGPL-3.0 — docker compose up and it runs. The dashboard is the commercial layer: Pro and Enterprise licenses via Lemon Squeezy, verified locally with a JWT. No telemetry, no seat rent.
How do I run it?
Four commands: clone the repo, copy .env.example to .env, set a NOUS_API_TOKEN, and docker compose up. PostgreSQL 18 + pgvector, Alembic migrations, and the local models come inside — first recall in minutes, not days.