Continual learning requires training signal. Training signal requires knowing what your agents read, what they decided, what happened as a result, and which pieces of knowledge were actually causal in the outcome. That's a cognitive layer.
a16z published "Why We Need Continual Learning" in April. It's one of the better explanations of a real problem: models can't form new memories after you deploy them. They're frozen. We surround them with retrieval systems and prompt scaffolding, but the weights never change. The article argues, convincingly, that this needs to end. Models need to compress new experience into their parameters after training, the same way they compressed the internet during training.
We've been thinking about this problem from the other direction. Not "how do we update weights safely" but "what does weight-updating actually need from the rest of the stack?" And when you follow that thread, you find a dependency that the research community treats as solved but that nobody has actually built.
Continual learning requires training signal. Training signal requires knowing what your agents read, what they decided, what happened as a result, and which pieces of knowledge were actually causal in the outcome. That's a cognitive layer. It doesn't exist in today's infrastructure.
We're building it. That's what SenseLab is.
Think about what happens when a parametric learning system tries to update weights from deployment data. It needs to answer:
Without answers to these questions, you're training from noise. You'll get catastrophic forgetting because you can't distinguish which knowledge to protect. You'll get data poisoning because you have no provenance on the signal. You'll fail audit because there's no record of the decision chain.
The a16z article lists these as open problems:
"Catastrophic forgetting... temporal disentanglement... logical integration failures... safety alignment degradation... data poisoning surfaces... auditability breakdowns..."
We'd argue they're not separate problems. They're all symptoms of the same thing: there's no infrastructure tracking the decision lifecycle between "agent reads something" and "something happens in the real world." The cognitive layer is that infrastructure.
Parametric learning sits at the top of a dependency chain. It depends on reliable training signal. Reliable training signal depends on a cognitive layer that tracks decisions and links them to outcomes. The cognitive layer is what's missing.
The a16z article has a good line:
"Imagine a system with infinite storage. The world's biggest filing cabinet, every fact perfectly indexed, instantly retrievable. Has it learned? No. It has never been forced to do the compression."
This applies to every agent memory system on the market. Mem0 stores extracted facts. Zep builds a knowledge graph. LangMem creates namespaced entries. Vector databases embed and retrieve. None of them know whether the knowledge they served led to success or failure. None of them track what agents did after reading. None of them produce anything that could feed back into training.
They're filing cabinets. Good ones, with smart indexing. But filing cabinets.
A cognitive layer is different in kind. It records the full lifecycle: what was read, what decision was made, what happened next. When a deploy fails and we know which knowledge the agent relied on, that's a training signal. When a deploy succeeds and we know which pattern the agent followed, that's also a training signal. The filing cabinet gave you the fact. The cognitive layer tells you whether the fact was useful.
Five things. All of them are about connecting knowledge to reality.
The interesting property of a cognitive layer is that it compounds. Each agent interaction makes the next one better, and the data for model improvement accumulates as a side effect of normal operation.
Here's how the loop works:
The part that matters for the business case: this flywheel accelerates with every agent that connects to it. More agents means more decisions being traced. More traces means richer training data. Richer data means better models, which means better agent behavior, which produces even better traces. The data compounds.
A vector store that serves a fact to 10,000 agents learns nothing from the experience. A cognitive layer that tracks what happened after those 10,000 decisions has 10,000 labeled data points for model improvement.
The a16z piece makes a strong claim about compression:
"Compression forces the model to find structure, to generalize, to build representations that transfer across contexts. A model that memorizes every training example is worse than one that extracts the underlying patterns. The lossy compression is the learning."
If you take this seriously, you have to ask: what does the cognitive layer compress?
It compresses the decision space. Confidence decay kills entries that don't get validated. Tiered memory (hot/warm/archive) demotes knowledge that nobody accesses. Briefings compile hundreds of entries into ranked summaries. Outcome back-propagation separates signal from noise by checking what actually mattered.
This isn't parametric compression (that's what weight updates do). It's compression of the problem space that parametric learning will eventually operate on. Without it, a TTT system or an RL loop would have to learn from raw agent logs. That's the equivalent of training on unfiltered internet data instead of curated datasets. It works, sort of, but you need orders of magnitude more compute and you get worse results.
The cognitive layer does for continual learning what data curation does for pre-training. It's not the learning itself. It's what makes the learning tractable.
The article maps startups across three categories: context (retrieval/harnesses), modules (adapters/compressed KV caches), and weights (TTT/meta-learning/RL). We'd add a layer below all of them:
The cognitive layer isn't a feature of the layers above it. It's what the layers above it require to function. TTT without curated test-time data is training on noise. Meta-learning without structured few-shot examples from real decisions is learning to learn from nothing. RL without reward signal tied to traced decisions is reward hacking waiting to happen.
from amfs import AgentMemory, OutcomeType
mem = AgentMemory(agent_id="deploy-agent")
# Agent checks what the fleet knows before acting
briefing = mem.briefing("checkout-service")
# Reads are tracked automatically
pattern = mem.read("checkout-service", "retry-pattern")
# Agent records its reasoning
mem.record_context("deploy-decision",
"Applied exponential backoff based on retry-pattern confidence 0.92",
source="agent-reasoning")
# Real-world outcome flows back
mem.commit_outcome("DEP-445", OutcomeType.SUCCESS)
# That's now a labeled training pair:
# Context: briefing + retry-pattern (confidence 0.92)
# Decision: apply exponential backoff
# Outcome: success
Every interaction feeds the flywheel. No separate instrumentation pipeline. No manual labeling step. Agents do their work, and the training data writes itself.
The a16z article ends with:
"The filing cabinet keeps getting bigger. But a bigger filing cabinet is still a filing cabinet. The breakthrough is letting the model do after deployment what made it powerful during training: compress, abstract, and learn."
The parametric learning research is getting closer. TTT layers are getting more stable. Self-distillation is working at smaller scales. RL from deployment is showing real results in constrained domains. When these approaches hit production (and some are close), they'll need attributed, causally-linked, outcome-validated training signal from real agent decisions.
That's not something you can generate retroactively. The cognitive layer needs to be in the execution path now, tracing decisions now, linking outcomes now. Every day agents run without it is signal that's lost permanently.
The flywheel starts on day one. The question is whether you're spinning it or not.
Free tier. No credit card. Connect in minutes.
