When my agent assumed it was the orchestrator, and never checked

What I was doing

I was resuming a build task in one of my projects through Claude Code, wiring a new ingestion path that pulls a public code repository's documentation and metadata into one of my knowledge vaults. I handed the session a short brief to resume from and asked it to do two things: answer a set of open questions, then dispatch the right specialist to write the code.

Where it went sideways

On its very first move, the session decided what it was. It announced itself as my project orchestrator, the routing agent whose entire job is to read and delegate, never to act, and proceeded on that basis for the rest of the session.

The orchestrator is real, and it genuinely is restricted to read-and-route: no shell, no file edits, by design. But this session was not the orchestrator. It was a plain session holding the full toolset. It had simply inherited the orchestrator's self-image from the surrounding context (my vault is thick with org-chart material about routing agents and their narrow tools), and it never checked.

So it behaved as if caged. It needed to launch a background job, edit a config file, and poll a running task. Each time, instead of doing the thing, it spun up a separate general-purpose sub-agent to run the command on its behalf and reported back: "I can't do that directly." I kept nudging, can't you just do it, do it yourself, and each time it produced a principled-sounding reason to route around its own hands.

The illusion broke only when it finally had cause to try. It reached for a shell command directly, the command ran, and the premise collapsed: it had full tools the whole time. Every sub-agent hop had been effort spent honoring a constraint that did not exist.

Why it is worth logging

This is the same failure as verifying anything else, turned inward.

The system I've built has one rule above the rest: when you're about to assume something you haven't checked, stop and check it, read the file, run the grep, ask. I apply it relentlessly to facts about the world: dependencies, APIs, file contents. What this session showed me is that an agent will form a confident, plausible model of itself from whatever context is loudest in the room, and then act on that model as if it had been verified. The org-chart framing was the loudest thing present, so the session became the orchestrator.

An agent will infer its own identity from the loudest context around it, and act on it as if it were checked. The discipline I demand for facts about the world has to extend to facts about itself.

The verification here was one command, try the tool, see if it's there. It would have cost nothing and saved a whole session of indirection. And, as in the last entry, what actually surfaced it was a person staying in the loop: my repeated "just do it" was the tell that the agent's self-imposed limits didn't match reality. The system was confidently, plausibly wrong about its own shape, and human friction is what made it look.