adlrocha - Stop Micromanaging your agents
@adlrocha Beyond The Code
SubscribeSign in
adlrocha - Stop Micromanaging your agents<br>The spectrum of agent relationships: interns, contractors and (swarm of) peers.<br>adlrocha<br>May 31, 2026
Share
Last week I wrote about the shift from writing code to running the kitchen. The argument was that engineering is moving away from individual code production and toward orchestrating systems of agents by designing the harness, the handoffs, and the specs.<br>But I left a question unanswered. If you’re running the kitchen, how close do you actually stay to the stove? When should you chime in to steer the agent, verify its work, or check-in progress?<br>That’s what I want to explore with you in this.<br>Three main relationships
The question of how humans and agents work together has been discussed under a few different names in the literature. Usually I’ve seen them referred to as Human-in-the-Loop (HITL), Human-on-the-Loop (HOTL), and fully autonomous systems. The academic framing is fine, but I feel like it may be missing the point a bit. The terminology is about position, i.e. where are you standing relative to the machine. What I think actually matters is the actual relationship you have with it, i.e. what is the role of each of you in the task at hand.<br>So here’s how I’ve been thinking about it. There are three relationships you can have with an agent, and most of us will (or at least should) operate in all three simultaneously depending on the task:<br>The agent as an intern : you delegate the work to it, it does the work, but you recurrently check on its job and you approve the output before anything ships. You can trust that the result is right or the work is done until a you check.
The agent as a contractor : you write the brief and set the boundaries; it calls you only when something falls outside them and they need to escalate a decision.
The agent as a peer : it operates with its own authority, and in multi-agent settings, coordinates directly with other agents on your behalf and you don’t need (or get) to do much as the task makes progress.
I don’t think these are three competing philosophies, and while many of us still treat agents as interns, we are seeing more and more contractors and peers in the wild. It really depends on the task you are working on. The right setting depends on the stakes, the reversibility of the action, and whether there’s a clean way to verify the output (here it goes again, how well can one define a long-running task inside of an objective self-verification loop determines the ability to implement truly autonomous agents).
The agent as an intern
This is where most of us are today, whether we call it that or not.<br>The intern relationship is about automating the routine parts of a job while keeping a human as the decision-maker for everything that matters. The agent handles the repetitive, mechanical work, e.g. the first-pass code review , the boilerplate, the migration scripts, the test generation, and you handle the calls that require actual judgement. It’s not that the agent is doing less; it’s that the human’s attention is now reserved for the decisions worth making. You’re still the micro-manager, but you’re micro-managing fewer things.<br>Every time you review a Claude Code PR before merging, you’re in intern mode. The agent proposes; you decide. OpenAI’s Agents SDK and LangGraph both ship this as a first-class primitive: the agent hits a checkpoint, execution pauses, waits for explicit human approval, then resumes from exactly the same state. The human is never removed from the loop, they’re just freed from the parts of the loop that didn’t need them.<br>The deeper value of the intern model is what it prevents as much as what it enables. Because the human sees every output before it acts, the agent can’t drift significantly. I t can’t silently optimise for the wrong thing, can’t go south on a Tuesday afternoon without anyone noticing. Misalignment is caught at the gate, not discovered three weeks later in production (if the human is not looking and blindly pushing the code, that’s on him). This is why the EU AI Act Article 14 (effective August 2026, and yes, the over-regulatory EU being its usual self) mandates human oversight for high-risk AI systems in credit, employment, law enforcement, and medical diagnostics.<br>The intern model isn’t only relevant to coding. Think about what it would look like for a travel agent: AI handling rebooking for a cancelled flight, confirming seats for 95% of passengers autonomously, pausing only when it encounters a first-class international itinerary with a loyalty override and a fare class requiring manual reissuance. The agent is explicitly instructed in the actions (usually in code) that it should fallback to its humans for confirmation . The same pattern applies to agents for other types of non-coding tasks like contract approvals, vendor renewals, any workflow where most decisions are routine and a small...