At Automattic, each quarter we run HACK week: a week where we step away from our usual work and spend time exploring something new.
For this HACK week, I decided to focus on something that’s been circling in my mind and that I’ve also noticed among my coworkers:
What happens to my understanding and mental energy when I run multiple AI agents?
In this blog post, I’ll share what I found.
tl;dr
I started by formulating a few statements that capture the idea above. Eventually, I arrived at the following main hypothesis:
Managing multiple independent AI contexts may increase cognitive cost.
The sub-hypotheses I started with:
- More contexts → more fatigue, less patience
- Understanding becomes selective
- There’s friction in coordinating agents
- Review quality drops when we focus on too many things
- Familiarity with a codebase helps with verification
- Our mental state changes how we experience the same agent behavior
- Self-monitoring helps me notice when my “mana” is running low
Most of these held up, but the first one didn’t. The survey had someone running just two agents reporting maximum fatigue, while people running more reported less. Turned out that counting agents doesn’t predict anything.
So the revised version is:
It’s not how many agents we run, but how much attention each one demands from us.
How I approached it
The three main sources for the data are:
- Structured self-observation
- Structured survey that I sent to several seasoned devs who regularly use AI
- Many unstructured discussions among coworkers on Slack
Each source contributed in one way or another. The third one helped me vaguely form the hypothesis, and the first two helped me clarify it.
I particularly found the structured self-observation to be interesting. Instead of trying to remember how I felt at the end of the day, I started logging work in blocks, in real time. For each block, I tracked:
- how many independent AI contexts I was managing
- fatigue at the beginning and end
- patience at the beginning and end
- how deeply I reviewed the work
- how hard it was to reload the context
- what caused friction
I also logged breaks, because, as we all know, recovery is important too. 🙂
A simplified example looked like this:
| Block | Contexts | Fatigue | Patience | Notes |
|---|---|---|---|---|
| Monday, ~71 min | 3–4 | 1 → 6 | 7 → 3 | Context switching and long responses were the biggest drain |
| Break, ~1h nap | — | 6 → 1 | 3 → 7 | Strong reset |
| Tuesday, ~90 min | 1 | 1 → 2 | 7 → 7 | Similar agent friction, almost no irritation |
This is obviously not scientific proof, but it gave me something much more useful than relying on my memory of how the week felt.
What I noticed during the week
I realized that I usually don’t care about the whole journey an agent takes to solve a problem. Most of the time, my loop is:
give task → let AI work → inspect result → move on
I go deeper when:
- Something feels risky (think security)
- Something is unfamiliar (how much do I understand this?)
- It’s architectural in nature (does it make sense from a high-level perspective)?
- It’s wrong (“what are you doing, Claude?” :D)
- Or, it’s simply interesting to me.
What tired me the most was switching between contexts, remembering what each agent was doing, rebuilding context (in my mind) when an agent came back, and reading long answers when I only needed one or two important things.
I also kept repeating the same prompts, which contributed to less patience and more friction:
- “keep it short”
- “test it end to end”
- “CI is failing”
- “on to the next issue”
I noticed the biggest difference when I switched from several independent sessions to just one Claude session, working through issues sequentially. The same annoyances were still there, but my fatigue barely increased, and I remained patient.
So I decided, instead of focusing on “how many agents can I run?”, I focused on “how many separate contexts can I comfortably keep in my mind?”
🧪 A coworker called this mental energy “mana”, and I liked that analogy. I also noticed that self-monitoring helps: once I notice my mana is dropping, I can take a break before I hit higher levels of irritation.
What the survey showed
I also sent a short survey to experienced developers who regularly use multiple AI agents. Some insights:
- Most respondents felt like they got more done with AI.
- Understanding is selective
- Architecture, security, unfamiliar code, and something looking wrong are common reasons to drill deeper.
- Verifying AI-generated work is harder when the codebase is unfamiliar.
- This was interesting to me, and a good debate here is to define what verifying really means, but I won’t go that deep in this blog post
- Context switching and long responses show up often as sources of fatigue.
- This confirmed my self-observation findings as well.
- People sometimes move forward because the result looks correct without deeply reviewing everything.
The result that broke my first hypothesis: the number of agents alone didn’t predict fatigue at all. Some respondents running only two agents rated both fatigue and context-reload effort at 7/7, while others running more reported lower numbers on both.
I was initially assuming that having too many Claude sessions is what drains me, but then I realized that it’s actually when I shift attention and the intensity of attention that’s the real cause of the drain. The survey also suggested that, so it seems like a nice fit.
Final thoughts
Using multiple agents is okay, but I want to be more aware when I do it, rather than subconsciously optimizing for the number of PRs generated or issues closed.
- Prefer one independent coding context when the task needs real focus.
- Run multiple contexts when the extra speed is actually worth the mental cost.
- Ask agents to “keep answers short, verify things end to end, and keep working until you need a decision from me”.
- Pay attention to my own “mana” and take a break before it reaches zero.
None of this is revolutionary findings 🙂 But having a better model of what actually drains me already makes working with AI agents feel better.
In my future AI usages, I’ll try dropping this blog post as a reference and see if things magically solve themselves 🙂
Props to Michal Iwanow for reviewing a draft version of this blog post.
bor0's reflective blog 