The mental model: a judgment layer, not a memory store
Most AI memory just stores text and returns the closest match. Cognition stores judgment, tracks whether it is still true, and decides when to trust it. Get this one distinction and every other feature makes sense on its own.
Here is the whole product in one sentence: a memory store answers "what did we write down about X?" Cognition answers "how does this team actually handle X, who figured that out, and is it still true?" One returns text. The other returns a decision. Almost everything that surprises people about Cognition follows from that difference.
Why "more memory" is the wrong goal
The intuitive fix for a forgetful AI is to give it more memory: index everything, embed every document, retrieve the nearest chunks. It feels right and it scales badly. A pure store has three failure modes baked in. It treats every note as equally true, so last year's wrong answer ranks next to this month's correct one. It returns the nearest match even when there is no good match, padding your context with plausible noise. And it strips provenance, so you get an answer with no idea whose judgment it was or whether to believe it.
The problem was never storage capacity. It was judgment: knowing which of the things you remember is worth acting on right now. That is the layer Cognition adds.
Store versus judgment, side by side
| A memory store | Cognition |
|---|---|
| Saves everything you feed it | Saves only human-approved skills |
| Returns the closest text match | Returns an executable skill: steps, checks, and the why |
| Treats all notes as equally true | Tracks freshness and decays stale guidance |
| Always returns something | Returns a fast no-match when nothing fits |
| Anonymous chunks | Attribution: whose judgment, last confirmed when |
The "always returns something" row is the quiet one that matters most. A system that never says "I don't know" trains your agent to chase whatever it surfaced. A fast, honest no-match keeps the context window clean for the actual work.
The unit is a skill, not a chunk
Because Cognition stores judgment, its unit of memory is a skill: a trigger, ordered steps, checks, and the reasoning. That is what gets loaded before the agent reasons, which is a genuinely different timing than search. A search result shows up when you go looking for it. A skill shows up because the situation matched its trigger, before you knew to look. That shift, from "retrieve on demand" to "prime on recognition," is where the time savings live.
When it fires on its own
Cognition is autonomous by default. It activates without you asking in four situations, each tied to a real signal rather than a guess:
- You start meaningful work: it loads the skills and project context relevant to the task.
- You get stuck (several tool calls, no real progress): it surfaces a teammate's trace that got past the same wall.
- A goal fails even though the individual tool calls succeeded: it records the failure and proposes a stricter workflow so it does not recur.
- A reusable workflow appears: it offers, exactly once, to capture it as a skill.
When to call it yourself
The rest of the time it waits for you. Reach for it explicitly when:
- You are unsure which command or skill fits: ask, and it ranks options by ROI.
- Several approaches are plausible: "what should we do here?" routes through cognition_decision_tree and your team's stored decision patterns.
- You want proof of impact: "show me my stats" and "what did Cognition use?" make the value and the activity inspectable.
- You are about to reuse a skill you do not fully trust: "does this skill work?" smoke-tests it before you rely on it.
When to skip it entirely
Knowing when not to use a tool is part of using it well. A genuine one-off, a throwaway script you will delete in an hour, a question with no reusable lesson, does not need a skill and will not get one. Cognition is built to stay quiet when context is thin. It would rather fail fast with a clear no-match than guess slowly, because a confident wrong answer costs more than an honest "nothing here."
The rule of thumb that covers most cases: if you would be annoyed to solve it again, it is skill-worthy. If you will never see it again, let it go. You do not have to curate; the friction tells you.
Why this model compounds
Put the pieces together and you get a system that gets sharper rather than noisier with scale. Approval keeps junk out. Attribution keeps trust in. Outcomes promote what works and decay retires what stopped working. A pure store does the opposite: the more you add, the harder it is to find the one right thing. Cognition is designed so that more usage means better recall, not a bigger haystack.
Next steps