Pedagogy is not memory.

Two people study for the same test. Both read the same material. Both take the same notes. One aces it. The other doesn't.

The information was identical. The learning was not. That gap — between what you know and how you know it — is pedagogy. It's what separates a person who can reason with their knowledge from a person who can only recall it.

Every AI memory tool shipping right now works on the first half. None of them work on the second.

What's in the water

Nous Research just shipped Hermes Agent, a genuinely great piece of software. It's a local agent runtime with skills, cross-session memory, messaging bots on Telegram and Discord and Signal, scheduled cron tasks, serverless deploys. Their marketing lists "agent-curated memory with periodic nudges" and "builds a deepening model of who you are across sessions." MIT open source. Built by a credible AI research shop. You should run it.

Anthropic ships Claude Code, which you're probably already using if you're reading this. Cursor ships Cursor Agent. Aider ships Aider. GBrain ships a markdown-native org brain. Karpathy ships a personal wiki pattern that agents edit while you sleep.

All of these products work on memory. All of them treat "remembering what happened" as the hard problem. They compete on retrieval latency, graph quality, session persistence, integration count. It's a crowded, well-funded, legitimately useful category.

And collectively, they solve maybe 10% of how human learning actually works.

Sleep is one mechanism. There are ten.

The most popular memory pattern in AI agents right now is sleep consolidation — an overnight agent process replays the day's events, summarizes them, and writes them into long-term storage. This is directly modeled on what the hippocampus and neocortex do during REM sleep.

It's real neuroscience. It's a good pattern. It is also one of roughly ten mechanisms that make human learning actually work:

| Mechanism | What it does | |---|---| | Forgetting curve | Memories decay on a time constant (Ebbinghaus, Weibull) | | Spaced retrieval | Reviewing at the right interval slams retention back to baseline | | Sleep consolidation | Hippocampal replay → neocortical storage | | Prediction-error learning | Dopamine spikes when predictions are violated; model updates | | Active retrieval / testing effect | Being quizzed strengthens memory 3× over re-reading | | Interleaving | Mixing topics beats blocking (ABC > AAABBBCCC) | | Elaborative encoding | New info hooks onto existing mental schema | | Schema abstraction | After N instances, the brain extracts the rule | | Emotional salience | Amygdala flags "this matters" → hippocampus prioritizes | | Metacognition | Knowing what you don't know; attention gating |

If you look at any of the agent memory tools, they implement one or two of these. Most implement one: storage + summarization. The rest of the stack is entirely unmodeled.

This matters because the mechanisms don't compose additively. Sleep consolidation without active retrieval just stores mediocre data. Active retrieval without a forgetting model doesn't know when to trigger. Prediction-error learning without schema abstraction is just noise. The learning we care about — the kind that makes two people with identical information perform differently — emerges from the interaction of many mechanisms.

What Cognition builds

We're not an agent. We're the pedagogy layer above your agent.

Concretely: we fit a Weibull survival curve — R(t) = exp(-(t/S)^β) — per employee, per concept, on top of whatever memory stack you picked. We don't care if it's GBrain, mem0, Letta, Zep, or a plain markdown folder. Your agent — Claude Code, Hermes, Cursor, Aider — reads from that substrate and logs concepts to us through MCP. We compute decay. We project forward. We know who on your team is about to drop below 60% retention on what concept, by when. Then we route a nudge through a channel they already use.

That's the base layer. On top of it, we're adding the other mechanisms: spaced retrieval in the nudges themselves (replacing passive "here's the refresher" with active "what's step 3?"), prediction-error learning on CEO decisions (training a behavioral model that gets sharp fastest when it's wrong), attention gating, metacognitive surfacing. Each one is a discrete feature. Each one closes a specific gap.

Where Hermes (and every other agent) sits

Hermes is the best current answer to "I want a powerful personal AI that runs anywhere and talks to me on every platform." That's a real product with a real buyer. We're not competing with it — we ride on top of it. One line in their config:

hermes mcp add cognition-clo @cognition/clo-mcp

And every concept the agent touches starts flowing into your team's retention model. The agent handles the interaction. We handle the pedagogy. The substrate — your Notion, your Gmail, your repo — stays where it is.

This is the three-layer stack we build for:

┌─────────────────────────────────────┐
│   COGNITION (pedagogy layer)        │
│   Weibull · decay · nudge timing    │
│   org projection · behavior model   │
├─────────────────────────────────────┤
│   HERMES / Claude Code / Cursor     │
│   memory · skills · messaging       │
├─────────────────────────────────────┤
│   Notion · Gmail · Slack · repo     │
└─────────────────────────────────────┘

Pick your runtime. Pick your substrate. We're the layer on top that makes the whole thing smart about humans forgetting things.

Why this ordering matters

There's a version of this post that positions Cognition as a competitor to Hermes. It would be more clickable. It would also be wrong. Hermes solves a problem we don't solve (great personal agent runtime, anywhere, any model). We solve a problem Hermes doesn't solve (team-wide retention math, enterprise pedagogy, dated predictions about who will forget what). Both products exist in a world with both products. Neither of us needs to be replaced.

What we both replace is the zoo of single-purpose tools that came before us. Standalone LMS. Standalone knowledge base. Standalone nudge app. Those products assumed an org has to install infrastructure to make learning work. We assume the infrastructure is already there — it's the memory stack your team is already using — and the job is to add a mathematical layer on top.

Your organization has memory. We make it better.

What's next

We're currently modeling two of the ten learning mechanisms. The next two on the roadmap — active retrieval in nudges and prediction-error learning on manager decisions — take us to four. After that, metacognition (surfacing "here's what you don't know about your own team"), then emotional salience tagging (weighting concepts tied to incidents, wins, or losses), then schema abstraction (building per-person decision rules from accumulated examples).

Every one of those is a product feature, a research finding, and a moat. None of them replace your agent. None of them replace your memory stack. All of them compound on top.

If you're running Hermes, or Claude Code, or Cursor Agent — you're already 90% of the way there. You just need the layer above.