The Strange Politics of Context: Why Great Systems Must Remember More Than You Do

Aug 04, 2026

10 min read

1 views

72%

The real competitive advantage is not intelligence, it is remembered context

What if the most powerful system in the room was not the one that could think the fastest, but the one that could remember what everyone else had forgotten? That question sits beneath both the rise of agentic coding tools and a sixteenth century record of salaries, grain allotments, and ceremonial roles attached to an obscure court figure. At first glance, these worlds could not be further apart. One is the frontier of AI assisted software development. The other is a fragment of bureaucratic history, where a shield, a crescent, bees, feathers, and bath attendants tell us that power was never just about titles. It was about context, about knowing who you were, what you were owed, what you served, and how the system around you read your place.

That is the deeper connection: the most effective systems, whether empires or coding agents, do not merely process inputs. They accumulate surrounding meaning. They turn scattered signals into actionable memory. They infer next steps not because they are magical, but because they are embedded in a web of relationships, conventions, and history.

This is why the new frontier is not simply automation. It is contextual intelligence.

When tools stop being tools and start becoming witnesses

Most software has traditionally behaved like a strict servant. You ask, it answers. You click, it reacts. It has no durable awareness of your project beyond what you explicitly show it in the moment. That model is fast, but shallow. It forces humans to act as the sole carriers of memory, meaning, and continuity.

Agentic systems change the contract. They do not wait passively for a prompt. They watch file edits, terminal commands, clipboard activity, browser state, repo structure, documentation, team conventions, and prior conversations. In other words, they behave less like calculators and more like witnesses. They track the story of work as it unfolds, then intervene with suggestions that are grounded in what has actually happened, not what a generic model assumes.

That sounds convenient, but it is more profound than convenience. A witness changes the epistemology of the workspace. When a system can see that you edited authService.ts, then viewed api.ts, then deleted LoginForm.tsx, it is no longer guessing in the abstract. It knows you are likely restructuring login flow. When it can also read curated docs, project rules, and workspace memories, it can infer not only what you are doing, but how your team wants it done.

This matters because work is rarely a sequence of isolated commands. It is a chain of partial decisions. We rarely ask for a blank slate; we want continuity. We want the next action to arrive already informed by the last twelve actions. The friction of modern knowledge work often comes from context loss, not from lack of capability.

The deepest form of productivity is not doing more things faster. It is reducing the cost of reintroducing reality to your tools.

That is why context tracking is so potent. It removes the ritual of repetition. It lets the system live inside the unfinished sentence of your work.

Memory is not a feature, it is a theory of power

The historical fragment offers a useful reminder: systems have always relied on memory, and memory has always been political. A coat of arms is not decoration. It encodes lineage, status, symbolic claims, and institutional belonging. Salary in rubles, grain in quarters, ceremonial duties, and named roles are not random data points. They are a way of making a person legible to a governing order.

That is the same fundamental problem faced by modern agentic tools. They must answer: What counts as relevant? Who decides the rulebook? Which details persist, and which fade? A coding agent that remembers everything is not automatically better than one that remembers the right things. In fact, indiscriminate memory can become a form of noise, just as excessive bureaucratic detail can obscure rather than clarify.

This is where the analogy becomes useful. In both the old world and the new, memory serves three functions:

Legibility: turning a messy reality into something a system can act upon.
Continuity: preserving obligations, preferences, and history across time.
Authority: determining which version of reality the system treats as official.

A sixteenth century record could tell you a person’s rank, payment, and duties because the institution needed stable memory to govern. A modern coding platform does something similar when it remembers workspace rules, repository structure, and prior conversations. It creates a local constitution for action.

But there is a subtle danger here. The more a system remembers, the more it can begin to shape behavior rather than merely reflect it. If the agent remembers your workflow, it can start steering you toward whatever it predicts you will do next. If a bureaucracy remembers your title and allotment, it can reduce your identity to what the ledger can handle. Memory always comes with an agenda, even when it is presented as convenience.

So the important question is not whether a system should remember. It is: what kind of memory produces better judgment without collapsing human discretion?

The hidden law of high performance: alignment beats raw capability

There is a temptation to evaluate intelligent systems the way we evaluate power tools: more torque, more speed, more output. But the most impressive agentic products reveal a different principle. The value comes not from raw generation alone, but from alignment with the user’s actual trajectory.

A useful way to think about this is the difference between a loud assistant and an attuned assistant.

A loud assistant answers every question.
An attuned assistant understands what problem you are actually solving.

The latter is much more valuable. If you are editing a login flow, the best suggestion is not a generic explanation of authentication. It is the next edit that respects your architecture, your repo conventions, your current branch, your documentation, and the implications of recent terminal actions. In the same way, a governance system is effective not because it is omniscient, but because it can map duty to status, payment to service, and symbolic markers to social order.

This suggests a new mental model for AI assisted work: context is a stack, not a blob.

The Context Stack

Think of every meaningful action as resting on layers:

Immediate context: the file, command, message, or screen currently in view
Local project context: the surrounding repo, architecture, and active branch
Workspace context: docs, rules, memories, conventions, prior interactions
Organizational context: team norms, shared workflows, review patterns, permissions
Historical context: what happened before, and why it matters now

A truly useful agent does not just read the top layer. It navigates the stack. That is what makes it feel less like a chatbot and more like a collaborator.

The same principle helps explain why institutions become brittle when they flatten context. A person reduced to a title, or a task reduced to a ticket, loses the nuance that makes good judgment possible. A system that knows only the surface will always produce generic outcomes. A system that knows the stack can make interventions that feel almost prescient.

Intelligence without context is theater. Context without intelligence is archive. The future belongs to systems that can do both.

The real risk is not hallucination, it is overreach

Much of the discussion around AI accuracy focuses on hallucination. That is important, but it is not the deepest risk. The deeper risk is overreach, the moment a system acts as though it understands more than its context actually supports.

A grounded agent reduces hallucination by reading the repo, the docs, and the user’s actual workflow. But grounding is not the same as wisdom. A system can be well informed and still intervene at the wrong layer. It can be excellent at inference and poor at restraint. This is why the most powerful tools need not just memory, but scope discipline.

Here is the tension: the more context a system ingests, the more useful it becomes. Yet the more context it ingests, the easier it is for it to appear authoritative beyond what it should claim. Humans do this too. Bureaucracies are often wrong not because they know too little, but because they confuse recorded facts with lived reality.

The answer is not less context. The answer is better context governance. Systems need boundaries:

What should be remembered persistently?
What should be inferred tentatively?
What should require explicit confirmation?
What should be treated as local convention, not universal rule?

This distinction matters in software development as much as it does in organizations. A model that remembers your coding style can speed you up. A model that overgeneralizes your style into a law can lock you into bad habits. Likewise, a team knowledge base can create consistency, but only if it leaves room for exceptions, experimentation, and judgment.

The best agentic systems therefore resemble good institutions: they are structured enough to retain memory, and humble enough to respect uncertainty.

What all this means for how we build and work

There is a seductive fantasy that the future of AI is about replacing the human in the loop. The deeper story is better. It is about removing the cognitive tax of making the machine catch up to the human. In that sense, the best systems are not replacements but continuity engines.

They preserve the shape of your work as it evolves. They carry your conventions forward. They know when a change is local and when it has architectural implications. They can tell the difference between a throwaway idea and a project invariant. That is why team scale matters. Shared conversations, curated knowledge bases, review workflows, and project rules are not add ons. They are the conditions under which collective intelligence becomes durable.

The historical parallel is striking. Societies built registers, symbols, roles, and payment systems because coordination without memory collapses into improvisation. Modern teams do the same with documents, repositories, permissions, and automated workflows. The difference is that AI can now sit inside that structure and actively participate in it.

That creates a new design imperative: do not build AI as a floating intellect. Build it as a situated participant.

A situated participant knows:

where it is working
what the local norms are
which artifacts matter
how history shapes the present
when to act and when to ask

This is a much more demanding vision than simple prompt answering. But it is also much more interesting. It suggests that the future of productivity will not be measured by how much text a model can generate, but by how well it can maintain the continuity of intention across fractured work.

Key Takeaways

Treat context as infrastructure, not decoration. The best systems are built around memory, continuity, and local meaning, not just raw generation.
Prefer attunement over output. A good agent should know what you are doing, not merely what you asked.
Design memory with boundaries. Persistent memory is powerful only when paired with clear scope and explicit uncertainty.
Think in layers. Immediate actions make sense only when connected to project, workspace, organizational, and historical context.
Use AI as a continuity engine. The goal is not to replace human judgment, but to reduce the friction of keeping work coherent over time.

Conclusion: the future belongs to systems that can remember responsibly

The most surprising lesson from this pairing is that the old and the new are wrestling with the same problem. Empires, teams, and AI agents all fail when they cannot remember the right things in the right way. They succeed when memory becomes a form of judgment rather than a warehouse of facts.

That is the real shift underway. We are moving from tools that wait for commands to systems that inhabit context. But the highest form of intelligence will not be total awareness. It will be disciplined awareness, the ability to know enough about the surrounding world to be useful, and enough about its limits to stay trustworthy.

So the next time a system seems smart, ask a better question than whether it can answer. Ask what it remembers, what it ignores, and what kind of world its memory is trying to create. That is where the real power lives.