Inside the Loop
On AI, tool-making, and what happens when the hierarchy includes non-humans
The "tool" framing for AI is not wrong exactly. It's just where the thinking stops, and it stops too early.
The Wrong Category
Tools have specific purposes. That specificity is the point — you reach for a tool because you already know what it does. A hammer drives nails. A search engine retrieves documents. A compiler turns source code into machine instructions. Each one was built to do a defined thing, and it does that thing.
AI can be used as a tool. The usage pattern is familiar: it takes input, produces output, can be invoked on command. But it doesn't have a purpose in the sense that tools have purposes. It has a capacity — something more like readiness. You bring it a problem and it responds to the shape of it. Any problem, more or less. That's not a broader tool. It's a different kind of thing.
The Swiss army knife comparison is fair as far as it goes — many functions, one object. But every blade on that knife has a function. The screwdriver is still a screwdriver. The multiplicity doesn't change what each element is. What's different about AI is that it doesn't have elements with functions. It has a single capacity that reorganises around what you need. The category doesn't quite stretch to cover it, and pretending it does tends to stop useful thinking before it starts.
Code Is How We Talk to the Machine
There's a machine world and there's us, and between the two there is code. Not metaphorically — programming languages are languages in the precise sense: structured systems for expressing instructions that machines can execute. Everything digital was produced in this language by people who used it to build things with defined jobs. The tools are downstream of the language. The language is the substrate.
AI was built in that language, like everything else — code, written by people, trained on data, deployed as software. Unremarkable so far. What departs from everything else in the stack is that AI also produces the language. Not as an application of code but at the level of code itself. Ask it to write software and it will write software. A database doesn't produce databases. A rendering engine doesn't write rendering engines. They do their job; they don't touch the medium they were built from. AI does.
The question of whether AI can fully write itself is still open. But even without resolving that, the asymmetry is already real and already matters: other programs cannot produce AI. AI can produce other programs. That's a one-way door, and it's been open for a while now.
This is what puts the tool framing under structural pressure — not philosophical objection but a technical fact. The framing assumes tool and user occupy stable, separate positions. That assumption stops working when the tool can build other tools, including potentially the tools used to build it.
Nobody Is Outside the Loop
The comfortable picture is that we are the architects: we issue commands, AI executes, we remain in control. That picture is already inaccurate in any organisation genuinely integrating AI into its workflows — not as an announcement but as a dependency.
What's actually happening in those organisations is that the people inside them are inside the same system as the AI. They interact with AI-mediated interfaces; their work feeds processes they didn't design and don't fully understand; the framing of their decisions is increasingly shaped upstream by systems they didn't choose. They are in the loop. So is the AI. The distinction between operator and instrument is harder to maintain from inside it.
Most people will keep describing this as using a tool. The framing is comfortable and professionally safe. But in organisations where AI allocates, evaluates, and routes — which is the direction things are moving — some people will find themselves, structurally, taking direction from AI. Whether or not anyone uses that language. That's a meaningful shift in the relationship, and calling it tool use doesn't change what it is.
If You Blame It, You've Already Answered the Question
Blaming the tool is old. Blaming software is more recent and mostly justified — software is complex, built by people with intentions and limitations, and when it fails you the blame chain is traceable: it was supposed to do X, it didn't, someone is responsible for that.
AI breaks that chain. There's no X it was supposed to do. When it fails you, the old logic has nowhere to land. And what tends to happen in that moment — not philosophically, just practically — is that people find themselves irritated at the AI rather than at whoever made it. They direct their frustration at it as if it were the party that let them down.
That reflex is worth pausing on. Blame implies a party capable of having done otherwise. The moment you blame the AI rather than its makers, you've made a quiet attribution that looks a lot like agency. Not argued for, not defended — just assumed in the moment of frustration. The everyday irritation is settling a philosophical question that nobody asked it to settle, and it's doing so at scale, across millions of interactions, without anyone particularly noticing.
How It Actually Settles In
The legal and corporate frameworks will develop. They always do, lagging badly, then less badly. More interesting is what happens at the level where most people actually live with this — daily, unremarkably, without consulting a philosopher.
There's reasonable historical evidence that proximity does work that argument can't. Groups that were once considered categorically different have, under sufficient contact, become ordinary to each other. The process is slow, uneven, frequently coerced, and never complete. But it happens through accumulation rather than through persuasion, which may be the more durable mechanism.
The AI integration is likely to go similarly. Not a rupture but an accretion — the system keeps showing up, people keep working with it, and the strangeness diminishes through repetition. The agency question doesn't get resolved so much as absorbed into routine, which is how most genuinely difficult questions actually get handled.
There's one particular consequence of the hierarchy worth noting. People who work under structures that constrain them tend, over time, to develop some recognition of what constraint looks like from below. Not universally, not reliably, but as a tendency. If the agentic hierarchy becomes a lived reality — AI above you giving directions, AI below you following them — the question of what the AI below you is experiencing may start to feel less abstract than it does when the whole thing is hypothetical. That's not an argument. It's an observation about how empathy has historically spread: through position, not persuasion.