The closing weeks of 2025 brought intense discussion around context graphs — the idea that AI agents need to preserve decision traces, not just execute rules. The argument is compelling: enterprises don’t just need systems of record for data, they need systems of record for decisions. Capture the exceptions, overrides, precedents, and cross-system context that currently live in Slack threads and people’s heads, and you get a queryable record of organizational intelligence.

I agree this is valuable. But calling it a revolution misses something fundamental: we’re solving the wrong problem first.

Context graphs give agents access to past decisions. What they don’t solve — and what will define 2026 — is the trilogy of challenges that actually gate agent autonomy: memory, causality, and explainability.

The context graph narrative assumes that if we just capture decision traces, agents will learn from precedent and make better decisions over time. But this conflates access to information with the ability to learn from experience.

Consider what’s actually missing:

Memory systems that enable reflection. Current agents operate with episodic amnesia. Each interaction starts fresh. Context windows provide working memory, but there’s no persistent, structured memory of past decisions, their reasoning, or their outcomes. A context graph stores what happened — but it doesn’t give the agent the cognitive architecture to reflect on its own decisions, identify patterns in its mistakes, or adapt its approach based on experience.

Causal understanding. Decision traces show correlations: “We approved this exception when these three conditions occurred.” But correlation isn’t causation. Did the SEV-1 incidents cause the discount approval, or did they just coincide with end-of-quarter flexibility? Did policy v3.2 lead to better outcomes than v3.1, or did market conditons change at the same time? Without causal models, agents can’t distinguish signal from noise, can’t predict what will happen if they deviate from precedent, and can’t learn which factors actually matter.

Explainability that humans can trust. When an agent makes a consequential decision, stakeholders need to understand why. Current approaches to AI explainability focus on model internals: attention weights, feature importance, activation patterns. But that’s not what business users need. They need to know: “What data did you consider? Which policies applied? What precedents influenced your decision? What would have happened if input X had been different?” This isn’t about retrieving decision traces — it’s about making the agent’s reasoning transparent and interrogable in real time.

These three challenges — memory, causality, explainability — form an interconnected system. You can’t have true explainability without causal understanding (because “we did X because Y happened” isn’t an explanation without knowing that Y caused the need for X). You can’t build causal models without memory (because causality emerges from repeated observations across contexts). And you can’t have effective memory without explainability (because agents need to know why past decisions succeeded or failed to learn from them).

The context graph approach treats decision traces as a form of organizational memory — and it is, but it’s passive memory. It’s a library of precedents that agents can query. What it doesn’t provide is the cognitive architecture for agents to actively learn from experience.

Think about how humans develop expertise. We don’t just accumulate records of past decisions and retrieve similar cases. We build mental models of how systems work. We identify causal patterns. We recognize when rules should be followed and when they should be bent. We learn not just what to do in situation X, but why situation X differs from situation Y, and what factors actually drive outcomes.

Current agent architectures can’t do this. They can retrieve similar past decisions through semantic search or graph traversal. But they can’t build causal models from those decisions. They can’t distinguish between spurious correlations and genuine causal relationships. They can’t reflect on whether their past reasoning was sound or just got lucky.

This is why I’m skeptical of the narrative that agents will develop “deviant behavior” — that they’ll learn unwritten rules, find creative workarounds, and make judgment calls the way humans do. If it’s not defined, if it wasn’t in the training data, if there’s no mechanism for causal learning, the agent simply doesn’t have the cognitive substrate to develop genuine expertise.

What we actually need isn’t more human-like agents. What we need is agents with proper memory architectures that can:

Store experiences in a way that enables learning. Not just decision traces, but structured representations of context, actions, outcomes, and the causal relationships between them.

Build and update causal models. Learn which factors actually influence outcomes, distinguish correlation from causation, and predict consequences of deviations from precedent.

Reflect on their own reasoning. Identify when they made correct decisions for wrong reasons, when they got unlucky despite sound reasoning, and what patterns in their decision-making led to good or bad outcomes.

Explain themselves transparently. Surface not just what they decided, but why they weighted certain factors, what causal model informed their reasoning, and what uncertainties remain.

Causality is particularly critical because it’s where current AI systems fundamentally break down. Large language models are correlation machines — they’re trained to predict likely next tokens based on statistical patterns. They’re very good at this. But correlation isn’t understanding.

When an agent needs to decide whether to approve an exception, it’s not enough to know that “similar cases were approved in the past.” The agent needs to understand:

What factors actually caused those approvals? Was it the SEV-1 incidents? The customer’s strategic importance? The timing relative to quarter-end? The approver’s personal relationship with the account team?

What causal mechanisms are at play? Does high ARR cause exception approvals, or do high ARR customers just happen to have more leverage in negotiations? Does the policy exist because exceptions are genuinely risky, or because someone wanted a formal approval gate?

What counterfactuals matter? If we approve this exception, what happens? If we deny it, what happens? What evidence would change our decision?

These are causal questions, and they require causal reasoning — not just pattern matching against historical data.

The exciting development is that we’re finally getting tools to address this. Causal inference methods from statistics — do-calculus, structural causal models, counterfactual reasoning — are starting to be integrated into ML systems. We’re seeing research on causal discovery from observational data, on learning causal graphs from text, on using LLMs to generate causal hypotheses that can be tested.

But we’re still early. Most agent architectures don’t have any causal reasoning capability. They can retrieve precedents, but they can’t explain why those precedents matter or predict whether they’ll apply in a new context.

Explainability becomes critical as agents move from assistants to decision-makers. In regulated industries — finance, healthcare, insurance — explainability isn’t optional. When a lending agent denies a loan or an underwriting agent flags a risk, regulators and customers have a right to understand why.

Current approaches fail because they’re designed for data scientists, not business users. Showing attention weights or feature importance scores doesn’t help a loan officer explain to an applicant why they were denied. What helps is: “Your debt-to-income ratio exceeded our threshold, and we found no precedent for approving exceptions without additional collateral.”

This requires a different kind of explainability — not reverse-engineering model internals, but capturing the agent’s forward reasoning process. And that reasoning process needs to be:

Causal, not correlational. “We denied you because your credit score is 650” is a statement of correlation. “We denied you because credit scores below 680 historically have 3x higher default rates in our portfolio, and our risk model can’t justify the exception without additional collateral” is a causal explanation.

Counterfactual. “What would I need to change to get approved?” This requires the agent to reason about interventions: if you paid down $5K in debt, your debt-to-income ratio would cross the threshold. If you provided a co-signer, we could approve under policy exception 3.2.

Auditable. When regulators ask “why did you approve this risky loan?”, the explanation needs to reference specific policies, show what data was considered, demonstrate that protected attributes weren’t factors, and prove that the decision aligns with past precedent and stated risk appetite.

Context graphs help with the last part — they provide the precedent. But they don’t solve causal explanation or counterfactual reasoning.

What ties all this together is memory. Not passive storage of decision traces, but active memory systems that enable learning.

I think about this in layers:

Working memory. The context window — what the agent is currently attending to. This is relatively solved by modern LLMs, though we’re still figuring out how to manage long contexts efficiently.

Episodic memory. Records of specific experiences: “In case X, I did Y, and outcome Z occurred.” Context graphs provide this, but the structure matters. We need representations that capture not just what happened, but the temporal sequence, the causal relationships, the confidence in our understanding, and the lessons learned.

Semantic memory. Generalized knowledge extracted from episodes: “When customers have high ARR and service issues, exceptions are usually granted.” This is where pattern recognition and abstraction happen. Current systems do this through training and retrieval, but they don’t update semantic memory based on new experiences — they need retraining.

Procedural memory. Skills and strategies: “When evaluating exceptions, first check policy, then look for similar precedent, then assess causal factors, then route to the appropriate approver.” This is where we encode not just what to decide, but how to make decisions.

The breakthrough we need is memory systems that integrate these layers and enable genuine learning. Systems where:

Episodic memories inform semantic generalizations

Semantic knowledge guides procedural strategies

Procedural strategies generate new episodes

The whole system reflects on its own performance and adapts

This is fundamentally different from retrieving decision traces from a graph database. It’s about building cognitive architecture.

Here’s where I part ways with the “agents as humans” narrative. There’s a tendency to anthropomorphize — to imagine agents developing intuition, learning unwritten rules, making creative judgment calls outside their training.

I don’t believe in this. If something wasn’t defined, wasn’t in the training data, wasn’t captured in a structured learning mechanism, the agent doesn’t magically develop human-like expertise through exposure.

What we actually need is the opposite of anthropomorphization: systems that are more transparent and trustworthy precisely because they’re not trying to be human.

This means:

Explicit decision logic. Not “the agent developed an intuition,” but “the agent applied causal model X, weighted factors Y and Z, and generated explanation ABC.”

Audit trails. Complete records of what data was accessed, what policies were evaluated, what reasoning was applied, and what uncertainties remain.

Alerting systems. Automatic detection when agents make decisions that deviate from precedent, violate constraints, or operate in regions of high uncertainty.

Causal safeguards. Before taking consequential actions, require agents to articulate the causal model they’re using, the counterfactuals they’ve considered, and the confidence bounds on their predictions.

This isn’t about making agents more human-like in their reasoning. It’s about making them more machine-like in the best sense — systematic, transparent, auditable, and explicit about their limitations.

Context graphs are a good start, but they’re not the revolution. They’re infrastructure — necessary but not sufficient.

What we actually need to solve in 2026:

Memory systems that enable reflection and learning. Architectures that integrate episodic, semantic, and procedural memory, and provide mechanisms for agents to learn from experience, not just retrieve past cases.

Causal reasoning capabilities. Tools for agents to build causal models from observational data, distinguish correlation from causation, reason about interventions and counterfactuals, and make predictions with explicit uncertainty bounds.

Explainability that builds trust. Not post-hoc rationalization or attention visualizations, but forward-traced reasoning that shows what data was considered, what causal model was applied, what alternatives were evaluated, and what uncertainties remain.

Integration of all three. Memory systems that store causal models. Causal reasoning that informs explanations. Explanations that help agents learn from their mistakes.

This is the trilogy that will actually enable autonomous agents in enterprise contexts. Not because agents become more human-like, but because they become more trustworthy — systematic in their reasoning, transparent in their explanations, and genuinely capable of learning from experience.

The infrastructure players focused on context graphs are building valuable pieces. But the real breakthrough will come from whoever solves memory, causality, and explainability as an integrated system. That’s the challenge that will define 2026.