Skip to content

Driver Mode: Jumping levels of abstraction with agents

The hard part of running several agents isn’t starting them. It’s knowing which one needs your judgment.

During an agent-driven research session, one of my background agents turned red in its status line and kept retrying. I checked on it, saw it was stuck, and told the orchestrator to launch a plain agent instead. The work went on. Without that signal, I’d have waited on a result that wasn’t coming.

I didn’t need to follow every step of the background work. I needed a signal that something was wrong, access to the details, and a way to intervene. That’s what I mean by driver mode.

My setup uses Pi and Herdr. Below, I’ll walk through what I load into each session, which work I keep visible, and how I check results and keep the workspace usable. The operating principles apply beyond those tools.

This is for people already using agents to write code, do research, or explore data, who want to run several without losing track of the work. Autonomous agents in production need different guardrails and aren’t what I’m covering here.

Move between the overview and the decision

Donald Knuth called it “jumping levels of abstraction”: seeing things at many levels of detail, from high levels down to the lowest. With agents, I need both a view of where the work is headed and access to the specific decision that needs my context.

Think of driving with a map app. In the city, you zoom in to see the next turn. On a five-hour drive, you zoom out to check the route. You might reroute because you know about road construction the map doesn’t. Agents have similar gaps: a product’s cultural nuances, a codebase’s history, or what a research field already knows. An overview helps me notice where that context might be missing; the detailed view lets me supply it.

Two scarce budgets

The model’s context is limited. Tool definitions and instructions loaded up front take space alongside the task. Research shows that longer inputs can degrade a model’s reasoning, even before the context limit. This isn’t an argument against useful context. It’s a reason to avoid loading instructions for capabilities the current task doesn’t use.

My attention is limited too. If every agent’s tool calls demand a read, running another agent gives me another conversation to follow. I need enough status to decide where to look, then enough detail to understand what happened.

A carpenter can leave most of the shop’s tools within reach instead of carrying all of them on a belt. I want the same arrangement for capabilities and detail: less loaded by default, available when needed. Here’s how I apply that to the agents and to the view in front of me.

Start with a small core and load what the task needs

Pi is Mario Zechner’s open-source coding agent. Its default tools are read, write, edit, and bash. Its README puts it simply: “Adapt Pi to your workflows, not the other way around.” A small starting point gives me fewer places to investigate when the agent does something odd.

A fresh Pi session inside Herdr: a short startup screen, one loaded extension, and a plain bash call to answer the first question.

Installed isn’t the same as loaded. A skill, a set of Markdown instructions, normally appears in the prompt as a short description. The agent reads the full instructions when they’re relevant, or I can make the skill manual-only. Tools can be deferred until the agent searches for one it needs. Project settings let a research repo and a coding repo load different resources.

This lets me keep a capability available without putting all of its instructions into every session. I can ask Pi to make a skill manual-only or configure deferred tools, then review the changes. The agent handles the bookkeeping; I still decide what should be present from the start.

Add capabilities for a problem you actually have. Ask Pi to write an extension and run /reload, or browse the packages on pi.dev. Before installing one, read what it does. Pi’s docs warn that extensions run with your permissions and can access prompts, files, and credentials.

Then apply the keeper test: would you miss it if it were gone? My background-agent extension, goal extension, and cleanup skill each replace work I’d otherwise do inefficiently. That is the reason to keep them, rather than the fact that they are available. Less by default doesn’t mean refusing useful capabilities.

Choose what to observe, then choose your zoom level

Pi deliberately ships without sub-agents; Mario Zechner suggested running another Pi session in tmux instead. I use visible sessions for work I want to follow, and background agents for work I can leave unattended until a result or exception arrives.

Driver mode: keep the overview, zoom in where judgment matters, and inspect background work when needed.

Macro: find where your attention is needed. Herdr organizes visible sessions into workspaces, tabs, and panes, and shows whether an agent is working, blocked on a question, or done. An orchestrating agent can start, prompt, wait for, and read other agents through its command-line interface. I can check that view instead of reading each terminal to infer its state.

In the Kolmogorov–Arnold Networks (KAN) research session below, the four agents were named for origins, variants, efficiency, and applications. The orchestrator read their output and consolidated it into one summary, while their sessions stayed available for follow-up questions.

Macro: Pi ran four sub-agents researching Kolmogorov–Arnold Networks, read their output through Herdr, and consolidated it into one summary. The sidebar shows each agent’s status.

The consolidated output also flagged claims drawn from abstracts or search summaries rather than full-text reading. That gives me a specific place to inspect next. A finished status tells me the agent has returned its work; it doesn’t tell me those claims have been verified.

Micro: inspect what an agent actually did. When a decision needs my judgment, I step into that agent’s pane and inspect its conversation, tool calls, and output. In the research session, that means I can move from the consolidated summary to the searches and source checks behind it. Each visible sub-agent is another Pi session, so I can steer it directly.

Micro: each of the four Pi sub-agents works in its own pane, with tool calls and cost in view.

In the background. pi-subagents, a community extension, gives me a status line and the results of each run. Code review and evidence checks fit here because I care more about the verdict and its supporting evidence than watching every step. Those tasks can still be consequential. Background is a visibility choice, not a judgment about risk.

That status line caught the stuck agent at the start of this post. It sent my attention to the one run that needed an intervention, while the other work could continue.

Macro and micro are zoom levels for visible work. Background work stays outside that view until I need to inspect it. Either way, the signal tells me where to look, not whether the result is right.

A pane organizes work but doesn’t isolate it. Give parallel writers separate git worktrees so their edits don’t collide in the same checkout.

Check completion and keep the overview usable

Long runs need an agreed definition of done. I use pi-goal-x to keep an agreed goal and completion requirements in view; its /sisyphus mode follows an ordered plan. A separate model audits the evidence against those requirements before the goal can close. This gives me a check that isn’t performed by the agent doing the work. It is still a model, so I keep tests and my own review. The run has its own Herdr tab, where I can inspect it when needed.

The overview also needs upkeep. Finished agents sit idle, panes pile up, and worktrees and notes go stale. If I leave them all there, the status view gets harder to read. I keep a Janitor tab with a cleanup skill that knows my working directories and Herdr setup. It proposes what to close, merge, or archive, and I approve before it acts.

Three roles: an orchestrator for the overview, sub-agents for focused work, and a janitor for upkeep.

The goal extension gives me a completion check. The Janitor keeps finished work from obscuring active work. They solve different problems, and each passes the keeper test for my workflow.

Own the setup and the output

Updates can break extensions, and no vendor tests my exact workflow. Pi can often help diagnose and repair a broken extension, but the fix still needs checking. Adding a capability also means taking on its maintenance.

The same applies to the work the agents produce. A consolidated research summary still needs source checks. A code review is a verdict to assess, not permission to ship. When I share results with colleagues or use them in something that matters, I am responsible for them. You can delegate the work, but not the accountability.

Try the smallest useful version

A batteries-included setup may suit you better. You don’t need to adopt every piece of mine to test whether this approach helps.

Start with a task you understand well. Run one Pi session inside Herdr, then ask it to start a second beside it. Check two things:

  • Can you tell which agent needs your attention without reading both conversations?
  • When you step into one session, can you inspect its work and return to the overview without losing track of the other?

If either is difficult, that’s a concrete problem to solve before adding more agents. Add the first capability you actually miss, and nothing more.

There will be more agents making more decisions, faster. Our attention won’t grow with them. Keep capabilities within reach, keep the default view focused, and zoom in where your judgment matters. You’re still the driver.

If this kind of work gets you excited and you want to tackle applied research problems, come build with us at Whatnot. We’re hiring!

AI / ML

Every shop has a story. Help us build the platform behind it.