Agentic Minimalism: The Human Control Loop
your agents need a control loop and so do you
I have this habit. I’ll be working on something, and a question will cross my mind. Something tangential, something I could probably ignore. Probably something other people would shrug off.
Instead of ignoring it, I go down the rabbit hole.
AI agents have made this much worse.
When your agent can crawl across Slack, GitHub, Linear, Snowflake, Notion, and your local files, those nagging questions that never had answers before are suddenly just a query away. I can fire one off and get a detailed recollection across surfaces: the first time someone mentioned an idea, the first ticket in Linear, the first commit in GitHub, and the first launch update in Slack.
It feels incredibly productive. It feels like embracing curiosity and using newfound leverage to investigate more and move faster than I ever could before.
Clearly this is the future, right? This is how you get 10x leverage and get ahead?
I’ve also been noticing something else: a kind of low-grade exhaustion I can’t pinpoint.
I’m not overworked. If anything, I delegate a large portion of what I do. A surprising amount can be done from my phone using voice mode while I go for a walk. I have more capacity than ever to start things and feel less restricted than ever.
Yet it all still feels tiring. I end some days drained. Sometimes I have a hard time sleeping and can’t explain why.
Agents aren’t doing work for free
When you fire off an agent, you get the reward upfront.
You see it thinking and calling tools. You feel progress. Your dopamine starts buzzing as you imagine how long the same query would take manually, crawling through hundreds of thousands of lines of text across several systems.
You just did 100x the work for almost no effort.
Except it wasn’t free. You signed yourself up for work on the backend.
You need to validate the result. You need to imagine where hallucinations or bad assumptions could have entered. When it returns, you have to context-switch back into the thread, leaving attention residue that makes it harder to resume whatever you were doing before.
You’re paying a tax you didn’t see at the time of purchase because the purchase felt free.
It’s also not just you prompting the agent. The agent is prompting you.
Every result surfaces another thread to pull, another question, or a new “interesting” direction to investigate. The tool is generating tremendous amounts of work for you, and you’re absorbing it because it did so much for you.
AI reduces the cost of starting work. It does not reduce the cost of deciding what deserves your attention. In many cases, it increases it.
This is a control loop problem
When you design an AI agent, you define success criteria, guardrails, and limits on what it should pursue. You give it an objective and explicit non-objectives. You control what tools it can access and what it can change. You cap how long it can iterate before it must commit, stop, or check in.
Without those constraints, an agent will chase tangents, clutter its context window, and produce shallow work that misses your point.
AI power users naturally learn to do this for their agents. Most never think to build the same guardrails for themselves.
I certainly took too long to do it.
What I realized is that I need my own control loop: something that keeps me from spreading my attention too thin, limits the number of concurrent threads I allow, and forces me to measure impact rather than activity.
Luckily, the principles already exist. Cal Newport has written about them extensively in books like Deep Work and Slow Productivity. In the AI agent era, I think they matter even more.
Newport’s principles aren’t productivity hacks. They’re design specifications for the human control loop.
Do fewer things: limit concurrent threads
This is work-in-progress limiting.
Giving an agent several objectives at once increases the likelihood that it will drift or make mistakes. The same is true for you. Every agent you fire off and every thread you open is a claim on your future attention.
An agent “working in the background” is not actually out of mind. Some part of you is tracking that it will return and reserving capacity to evaluate it.
The fix is restraint: place a hard cap on how many concurrent threads you allow yourself to have open. This comes from the same logic as a Kanban WIP limit. Limiting work in progress improves flow through the whole system, even when every individual task feels cheap to start.
Work at a natural pace: govern iteration
AI creates real acceleration. It also creates the artificial sensation of it.
Results that once took hours can return in minutes. Every response surfaces new things to chase. There is no natural pause where you would otherwise decide, “This is enough. I need to move on.”
You need an explicit governor on how long you allow yourself to pursue something before you commit, stop, or put it somewhere for later.
Maybe that is a time block. Maybe it is a fixed number of iterations. Maybe the rule is, “I’ll create three variants and choose among them using criteria I defined before I started.”
This is exactly the stopping condition you would give an agent to prevent an endless loop. The difference is that you have to respect it yourself.
Measure impact, not output
Cal Newport calls it pseudo-productivity: measuring visible activity instead of meaningful results.
AI amplifies this because every query produces something that looks substantial. A sourced timeline or research report feels like serious work even when it did not advance anything that matters.
I still run exploratory prompts, but I try to anchor them in a question that informs a real decision. What will I do differently based on what I find? What uncertainty am I trying to reduce? What should exist when the loop closes?
If I can’t answer those questions, I should question whether I need another multi-stage agent run with five sub-agents and a research report.
A planning system with rules I actually follow
None of this works if it remains a set of ideas. You need a system that enforces the human control loop in practice, just as skills, permissions, tests, and stopping conditions constrain an agent.
I’ve been piloting a multi-scale planning system influenced by Newport’s work. It lives primarily in Notion, with Google Calendar as the source of truth for time. I operate it through Codex and Claude Code, which can read the relevant surfaces, prepare a briefing, and execute updates after I approve them.
The most important design decision is also the least magical:
The agent does not decide what I’m committed to.
It gathers evidence, shows me tradeoffs, and maintains the machinery. I choose what enters this week, what enters today, what I am waiting on, and what deserves calendar time.
Kanban as a commitment limit
I center the system around a simple Kanban board. It is not an endless task list. It is a visible constraint on what is allowed to occupy my attention.
The flow is:
Inbox: Unprocessed items that may or may not become real work.
Clarify: Work that might matter but is not shaped enough to act on.
Backlog: Understood work I want to retain but have not committed to.
This Week: Work I explicitly selected for the week.
Today: The small set I explicitly pulled into the day.
Waiting: Work blocked on another person or event.
Done: Work I completed.
Dropped: Work I deliberately decided not to pursue.
Done and Dropped stay separate because their histories answer different questions: What did I finish, and what did I consciously prune? Over time, the split shows whether I am completing selected work or accumulating commitments I later reject.
Interesting thoughts usually start in the Capture Buffer, not on the board. They earn an Inbox card only when there is a real action or obligation to evaluate. Once on the board, the status records my actual decision: shape it, retain it, commit to it, or wait on a dependency.
I also use hard caps. Today can contain at most one deep item and two shallow items. This Week can contain at most seven cards serving three outcomes. Clarify is capped at five.
Those numbers are not mathematically perfect. They are a governor. When something new wants to enter, I have to decide what moves out.
That tradeoff is the point.
A capture buffer that interrupts the interruption
As I work, interesting ideas and side quests appear. Many do not deserve a Kanban card. The temptation is to act immediately because the cost is now so low. I can dictate a prompt and have an agent halfway down the rabbit hole before I consciously decide whether the question matters.
Instead, I put the thought in a dedicated Capture Buffer in Notion.
This is my scratch space. Agents never add things to it. An inbox generated by agents would become another feed demanding my attention. The point is to externalize my interrupts, not manufacture new ones.
During shutdown, the agent walks through each unprocessed line with me. I choose whether to turn it into an Inbox card, preserve it as a durable note, do both, or drop it. The agent marks it processed but does not silently promote it into Today or This Week.
I do not have to decide whether an idea matters while it is interrupting me. I only have to capture it. The judgment happens later, on my schedule.
The Capture Buffer does not eliminate curiosity. It interrupts the interruption.
Morning planning as a bounded decision
Before I start firing off agents, I plan the day.
Codex or Claude Code reads the weekly plan, reviews the live calendar, and inspects the cards already selected for This Week or Today. It gives me a realistic picture of capacity and asks me to choose the intended win.
Then we pull at most one deep item and two shallow items into Today and shape the calendar around them.
This is different from asking an assistant, “What should I do today?” The agent is not inventing priorities from everything it can see. It is helping me make one decision from an already constrained set of commitments.
On one meeting-heavy day, the system did not generate an aspirational list of seven things. It identified two short prep windows and helped me choose one intended win: prepare sharp questions and initial hypotheses for a 2:30 product meeting.
I still deviate from the plan. Frequently. The plan gives those deviations a reference point. I can tell the difference between consciously changing direction and merely drifting.
Shutdown closes the loops agents opened
At the end of the day, the agent helps me capture loose obligations, route the Capture Buffer, reconcile Today, update waiting work, and review tomorrow’s calendar.
For active work, I leave a restart note: current state, next concrete action, what to open first, and any blocker. This converts the day’s residue into state I can resume tomorrow.
One evening, a long prototype and research thread had exposed that a product brief was underspecified. The easy failure mode was to keep building. Instead, shutdown forced the distinction into the open: the prototypes were conversation artifacts, not solution commitments. The next action was to clarify the problem, not add more features.
That was more valuable than another hour of output.
The ritual is also a psychological signal: this block is over. Move on. AI chat will never naturally give you that signal. It will always have another suggestion.
The system has to learn from friction
I do not think you can design the perfect planning system upfront. I certainly did not.
I started with a daily checklist as the main execution surface. In practice, it felt like another place to maintain. I wanted to drag a card into Today and drag it out when I finished. So the board became the day-of interface, and the daily plan became a lightweight record rather than a duplicate task list.
I also experimented with a more elaborate work graph that synthesized activity across systems. It was interesting, but it became another subsystem to reason about. I retired it when it stopped earning its complexity.
A personal control loop can become its own rabbit hole.
The test is not whether the architecture is clever. The test is whether it helps you choose, act, stop, and restart with less friction.
The human is part of the agent system
There is a temptation to describe this as an “AI chief of staff.” That is useful but slightly misleading.
The agent can gather evidence, compare the plan with reality, surface mismatches, maintain state, and make tradeoffs legible. It can remove enormous amounts of clerical and retrieval work.
But it cannot own the setpoint.
You do.
The division of labor is simple:
The agent gathers, briefs, and writes. I decide.
Nothing enters Today, This Week, or Waiting merely because the agent noticed it. Meeting notes do not automatically become obligations. Capture does not become commitment without a decision.
If the agent can launch ten times more work, the operator needs stronger WIP limits. If it can return results in minutes, the operator needs stopping conditions. If it can search every surface, the operator needs a clear question. If it can always suggest another direction, the operator needs a shutdown ritual.
The more capable the agent becomes, the more important the human control loop becomes.
AI gives you more capacity to begin. It does not tell you what is worth finishing.
The goal is not maximum output.
The goal is to direct leverage without letting it direct you.