TL;DR: We can look at how civilizations have managed context across large groups of people when designing systems for AI agents.

We’ve created digital intelligence, and quickly rediscovered an old truth about humans and organizations: being smart isn’t enough; you have to be well-informed.

In an age of information flood, humans struggle to stay oriented, so it’s no surprise agents collapse under over-information too.

Luckily, we’ve partially solved this problem already. Otherwise civilization wouldn’t scale. So how did we do it, and what lessons should we apply to agent systems?

Bureaucracy, aka the context machine

Picture this: it’s Tuesday, and you need to make a major decision by Friday. Everyone has a take: advisors, the other side, your own team… and none of it lines up.

could be for an acquisition, a permit, a technical decision, or even a presidential decision… any high-stakes, multi-party decision with a lot of moving parts.

Your inbox is a mess: half-formed opinions, conflicting notes, and “urgent” updates from every direction. It’s all fragments: different formats, motives, and levels of certainty.

The organizational bureaucracy kicks in. Someone opens a doc titled “Decision Brief.” Someone else starts a checklist. A calendar invite becomes an agenda. A spreadsheet becomes a forecast. Each artifact is an early compression pass; an attempt to turn messy, contradictory fragments into something a human can scan.

Managers compress too. They call their direct reports and mark the moment: this is critical, speak now. Not for more input, but for the right input.

Then comes the final pass: the chief of staff enters the room.

They cut anything that won’t change the decision, name the few real tradeoffs, and surface the top risks in plain language. They separate facts from assumptions, unknowns from disagreements, and make the next action unambiguous: decide X by Y, with Z as the fallback if the key assumption fails.

Now, it’s ready for you.

How human civilization scales

Yuval Noah Harari wrote about this in Nexus: A Brief History of Information Networks from the Stone Age to AI.

TL;DR: Information networks create cooperation at scale, but demand filters; without them, societies drown in noise.

The basic pattern is simple: as groups grow, they stop coordinating person-to-person and start coordinating through shared records and shared rules: ledgers, contracts, procedures, titles, agendas, minutes…

Those artifacts are a compression layer. They don’t preserve everything; they preserve what must stay consistent so thousands (or millions) of people can act together.

Scale isn’t “more information.” It’s better filtering: deciding what counts, what’s current, and what changes the next decision.

The absence of proper bureaucracy

Now picture the same Tuesday. Same deadline. Same stakes. Same flood of fragments. But no one is empowered to cut.

So everyone adds.

People forward “for visibility,” attach every doc “just in case”… nobody wants to be the person who missed the one detail that mattered.

By Thursday, you have more noise than you started with. The quality of your decisions degrades…

Enter: context rot.

Context rot: Agents fail like orgs

In 2026, we are asking agents to be as effective as a well-run organization. And predictably, they are failing in the same way: drowning in noise.

Simply put, we’ve been observing the same phenomenon in LLMs: performance decay over longer conversations or larger prompts.

TL;DR: Context rot is a phenomenon in LLMs where model performance, accuracy, and reasoning abilities degrade as the input prompt or conversation history grows longer.

This might be masked by improvements in model capability, but it’s there even with the best models.

If you’ve been using LLMs for a while, you know that the best answers come with a tight, focused prompt. The more you add, the more it “forgets.”

Retrieval helps. But no organization succeeds by just having a “very cool search engine” for their inbox. They succeed by organizing data, filtering it, and distilling it into the right context for each decision-making process.

And “just put everything in the context window” is the digital version of forwarding every email chain. It feels safe. It’s not.

A chief of staff for agents

What if we built a Chief of Staff for agents: a system that takes raw fragments, discards what won’t change the decision, and composes a brief that can be acted on? It rests on a few simple premises:

  • start with purpose: what decision is this context meant to move? If a detail doesn’t change the decision, it doesn’t belong in the working set.
  • forget on purpose: humans function by compression. We collapse experience into summaries, concepts, and a handful of cues we can recover later. Agents need the same controlled forgetting: multi-pass distillation that keeps signal and drops performative noise.
  • separate epistemic states: a usable brief distinguishes facts from assumptions, unknowns from disagreements, and risks from preferences. And it becomes practical because the “bureaucracy” is cheap to run:
  • filtering is computable: we can spend cycles on triage, cross-checking, and summarization the way organizations spend time on review and approval.
  • filtering is parallel: multiple small passes, each with a narrow job, beat a single, monolithic “stuff everything into the prompt” pass. Humans scaled with bureaucracy not because bureaucracy is pleasant, but because it is a repeatable way to turn fragments into action.

Contextrie

Contextrie is my attempt to build that pattern into a real package.

The name is a nod to compression: a context tree, and tri as in sorting.

The simplest version is:

  • “Clerks” surface, tag, and compress information.
  • A “chief of staff” composes the brief: what’s true, what’s assumed, what’s disputed, what’s unknown.
  • The operating agent receives a context that can be acted on.

ingest -> assess -> compose

You can follow along Contextrie on GitHub (read it, fork it, or star it), or join the conversation on the Contextrie Discord Community, the fastest way to influence what we build next.

It’s a work in progress. Issues, contributions, failure cases, and disagreements are all welcome.

Agentic problems are (basically) human problems

In the age of agents, it’s fine to steal from biology and human history, in this case, bureaucracy/organization. The brain forgets on purpose, then reconstructs what matters when it matters. Organizations do the same with briefs, agendas, and minutes. If we want agents that last, we should get inspired by the shape of what already scales.