Last week I had six Cursor conversations open. A financial risk engine in one. A LinkedIn posting tool in another. A survival research session in a third. My agent verification project in a fourth. A blog draft. A dog care knowledge base.

Each conversation knew its own world perfectly. None of them knew about the others. And the only system that held the full picture — the connections between projects, the decisions that rippled across them, the thread that tied “context rot” in one conversation to “session handoff” in another — was me.

I was the context window. And I was running out of tokens.

The problem nobody’s naming

Open any AI newsletter right now and you’ll find a dozen articles about context. Context windows are getting bigger (Gemini hit 2 million tokens). RAG pipelines are getting smarter. Memory architectures are evolving from “forget everything between sessions” to hierarchical stores with semantic retrieval.

All of that is about the agent’s context. The model’s ability to remember, retrieve, and reason over information.

But here’s what I haven’t seen anyone talk about: the human’s context is fragmenting faster than the agent’s context is expanding.

I’m not just using one AI agent. I’m having parallel conversations with multiple agents across multiple product spaces. Each agent holds a piece of my work. Each conversation contains decisions, reasoning, and context that exists nowhere else. And I’m the one who has to carry all of it in my head — switching between threads, remembering what I told which agent, keeping track of which conversation has the latest version of which decision.

This isn’t a hypothetical concern. It’s what my days actually look like.

You’re not imagining it — there’s data

A Boston Consulting Group study of 1,488 US workers, published in Harvard Business Review in March 2026, gave this feeling a name: “AI brain fry.”

Fourteen percent of workers reported experiencing it — mental fatigue from overseeing too many AI tools and agents. Symptoms include brain fog, difficulty focusing, headaches, and needing to physically step away from the screen to reset. Self-reported error rates among affected workers were 39 percent higher.

The finding that hit hardest: productivity increases when you go from one AI tool to two. It increases again — but less — with a third. After three tools, productivity drops. Not because the tools are bad. Because the human managing them has hit a wall.

The thing most cited as mentally taxing wasn’t using AI. It was overseeing AI — managing semi-autonomous agents that each need monitoring, context, correction, and human judgment at decision points.

The irony of agent proliferation

Here’s the twist that makes this personal.

I’ve spent the last two weeks building a context continuity system for my AI workspace. Session handoffs, context indices, transcript indexes, agent logs, daily recaps — a whole architecture designed to solve the problem of agents losing context between sessions.

And it works. My agents are better at picking up where they left off than they’ve ever been.

But the system I built to fix agent context didn’t fix my context. If anything, it made the problem worse. Now I have more projects, more conversations, more things happening — because the agents are more capable. The better the agent’s memory gets, the more I ask it to hold, and the more I have to track across conversations.

It’s the same paradox the BCG researchers found: AI expands your “sphere of accountability.” You don’t do less. You become responsible for more — more outputs, more monitoring, more information flowing through the same human brain.

What “human context loss” actually looks like

It’s not dramatic. It’s not forgetting your name or losing a document. It’s subtle:

  • Duplicate decisions. I’ve made the same architectural choice in two different conversations because I forgot I’d already resolved it in the first one.

  • Orphaned reasoning. I work through a complex tradeoff in conversation A, arrive at a decision, then start conversation B with the decision but not the reasoning. When the decision gets challenged, I can’t remember why I made it.

  • Version drift. Three conversations each have a slightly different understanding of what “the product” is because each one evolved the concept independently.

  • Context switching tax. Every time I jump between conversations, there’s a ramp-up cost. Not just for the agent (which can re-read its history) but for me. I have to remember where this particular thread is, what we decided, what’s still open.

  • The uncoined problem. A Dev.to article describes something I recognized immediately: when you’re under heavy operational load, you lose the cognitive surplus to name what’s happening to you. You’re too busy managing agents to step back and see the pattern. I couldn’t articulate “human context fragmentation” until I stopped building for a minute and thought about what was actually hurting.

Nobody is building for this

The AI industry is pouring resources into the agent’s context problem. Bigger windows. Better retrieval. Smarter memory. And that’s all necessary — agent context matters.

But the human context problem is different in kind, not just degree.

Agent context is a technical problem: how do you efficiently store, retrieve, and inject relevant information into a model’s working memory?

Human context is a cognitive problem: how does a person maintain coherent understanding across multiple parallel workstreams, each mediated by a different AI conversation, when the conversations don’t talk to each other?

You can’t solve a cognitive problem with a bigger context window. The human brain doesn’t have a context window to expand.

What would a solution even look like? I think about this now:

  • Cross-conversation awareness. Something that knows what’s happening in all my active threads and can surface relevant context from conversation A when I’m working in conversation B.

  • Decision registries. A single source of truth for decisions made across conversations — so I stop re-making them or losing the reasoning.

  • Cognitive load monitoring. Not just “how many tokens is the agent using?” but “how many threads is the human tracking, and are they approaching the wall?”

  • Unified project state. Not each agent holding its own view, but a shared understanding that all conversations can read from and write to.

I’ve been building some of this manually — my activeContext.md, my context index, my session handoffs. They help. But they’re duct tape on a structural problem. I’m the one maintaining the system that maintains my context. That’s one more thing to manage.

The three-agent rule

The BCG data suggests a practical heuristic: three concurrent AI engagements is roughly the human limit before cognitive returns go negative.

That doesn’t mean three tools. It means three active, semi-autonomous workstreams that each require your oversight, judgment, and context-carrying.

I’ve been running six to eight. No wonder my brain feels like it’s overheating.

The honest answer isn’t “use less AI.” The honest answer is that we haven’t built the layer between “what the agent knows” and “what the human knows.” We’ve been so focused on making agents smarter that we forgot the human is still the integration point — and the human doesn’t scale.

What I’m doing about it

I don’t have a product to sell here. I have a practice that’s evolving:

  1. I journal everything. Not for productivity theatre — because I literally cannot hold all the decisions and reasoning in my head across sessions. The journal is my external memory.

  2. I batch, not parallel. Instead of six conversations open at once, I’m trying to work in focused blocks — one project at a time, with clean handoffs between them.

  3. I write handoffs for myself, not just for the agent. My session handoff files now include “what I need to remember” alongside “what the agent needs to know.”

  4. I name patterns when I notice them. That Dev.to article was right — the act of naming frees cognitive space. “Human context fragmentation” is now a thing I can point to instead of a vague feeling of being overwhelmed.

  5. I’m watching this space. Because someone is going to build the tool that sits between the human and their fleet of agents, giving the human a unified view of everything that’s happening. And when they do, it’s going to matter a lot.

The real context crisis

Everyone’s optimizing for the agent’s context. Bigger windows. Better RAG. Smarter memory tiers.

The real context crisis is the human’s. My context is spread across a dozen conversations, half a dozen product spaces, and a stack of decisions I’ve made that live only in chat histories I’ll never re-read.

The agent’s context problem is getting solved. Mine isn’t. Not yet.

And I don’t think I’m the only one feeling this.

If you’re managing multiple AI agents and feeling the cognitive load, I’d love to hear how you’re handling it. Find me on LinkedIn or reach out through this site.