I wrote this in my notes late one night:
It never ceases to fascinate and amaze me just how much human civilization has progressed in a few hundred years. The universe is 13 billion years old and humans maybe a few hundred thousand years. Yet almost all the change the world has seen has been in the last few hundred, and arguably the last few decades. A few hundred years compared to the billions of years in the universe is minuscule. Where could we be in a million years? A billion years?
We now have artificial beings, 1's and 0's, artificial neural synapses, weights and biases, stored in a file that can produce probabilistic symphonies that are indistinguishable from magic, from reason, from emotion and beauty. Do we not realize what we have created? The profound nature of where we all stand, the time that we live in and the excitement, awe and terror for what might be yet to come.
Reading that back, I feel two things simultaneously. First: yes, that's real. That feeling of standing at the edge of something vast. Second: I probably wrote it while frustrated with something mundane, a broken context window or a hallucinating agent. The awe often comes from frustration. The profundity crashes into the plumbing.
That collision is what I want to explore here. Both the awe and the tedium are real. Neither erases the other. And the failure to resolve the tension might be the most honest thing I can say about building AI right now.
Here is what building AI agents actually looks like day to day.
About 95% of the time, the work feels indistinguishable from any other software engineering. Debugging JSON parsing errors. Tuning temperature settings. Fighting with rate limits. Restructuring prompts because the model keeps going off-script.
The other 5% of the time, something shifts. You watch your agent handle a conversation you didn't explicitly program it for. It makes a connection you didn't anticipate. It responds to an edge case with something that looks, from the outside, like judgment. And for a moment you think: I just built something that reasons.
Then the next API call throws a timeout error, and you're back to debugging.
What interests me about the 95/5 split is not that it exists, but that most discourse about AI lives entirely on one side or the other. The breathless futurists talk about AI as if every day is the 5%. The pragmatic engineers talk about it as if the 5% is just anthropomorphism you should train yourself out of. Neither camp seems fully honest. The honest experience is the uncomfortable middle.
One thing worth paying attention to: different agent frameworks don't just differ in APIs. They embed fundamentally different philosophies about what agency is.
Take the Claude Agent SDK. The model operates as a reasoning core. You give it tools, constraints, and context. It decides what to do, when to use which tool, how to sequence actions. The architecture assumes the model is a thinker. Your job is to give it the right instruments and get out of the way.
OpenAI's function calling approach tells a different story. The model maps inputs to function calls with reliable precision. Given this input, which function should I route to, with what parameters? The tight coupling between input classification and function execution makes it excellent for well-defined task boundaries. The architecture assumes the model is a router. Your job is to define the right functions.
Same underlying technology, different frames. And the frame shapes everything downstream. If you think of your agent as a thinker, a hallucination feels like a cognitive failure. If you think of it as a router, a hallucination is a misconfigured mapping. Same behavior, different relationship to it. The framework shapes what you can see, and none of them may see the whole picture. Maybe agents are something new that doesn't fit cleanly into existing categories, and the frameworks are all projecting familiar metaphors onto unfamiliar territory.
Think about a surgeon.
A surgeon cuts into a human body. That's extraordinary. The trust, the precision, the intimacy of working inside another person. It should feel miraculous every single time. But the surgeon's day is also logistics, paperwork, insurance negotiations, keeping their hands steady, managing fatigue. The profundity doesn't disappear, but you can't dwell in it while you're making an incision. The work requires distance from the meaning of the work.
Building AI agents is developing a version of this same dynamic. We are building systems that reason, that communicate, that (in some loose, contested, philosophically loaded sense) understand. But the work of building them requires you to relate to them as engineering artifacts. You need to be able to say "this stupid agent keeps failing on step 3" without the weight of "this artificial being I brought into existence is struggling to function" attached to every debugging session.
The late-night moments, the ones where the profundity breaks through, tend to happen when you're too tired to maintain the professional distance. When the frame drops and you see, freshly, what's actually in front of you. That might be telling.
There's a question underneath all of this that I've been circling without quite landing on.
At what point does an agent have something like interests?
I want to be careful here, because this question can quickly devolve into either dismissive reductionism ("it's just statistics") or mystical hand-waving ("it's conscious"). Neither of those feels right to me. What I'm pointing at is more specific.
When I build an agent and give it a goal, it pursues that goal. It selects tools, sequences actions, adjusts its approach when something fails. It encounters a problem, considers options, picks one, evaluates the result, tries something else if needed. Is that agency? Or is it a very convincing simulation of agency?
The strongest version of the "it's all statistics" argument comes from researchers like Bender and Koller, who argue that language models manipulate linguistic form without ever accessing meaning. On this view, an LLM that appears to reason about consequences is doing something fundamentally different from reasoning: it's predicting which tokens would follow a description of reasoning, based on patterns in its training data. Agency requires understanding what your actions cause in the world. Next-token prediction, no matter how sophisticated, doesn't get you there. I take this argument seriously because it identifies a real gap. The mechanism (token prediction) and the behavior (apparent reasoning) operate at different levels of description, and it's genuinely unclear whether the mechanism can produce the real thing or only a convincing imitation.
But there's a response to this that I also can't dismiss, one that philosophers call functionalism. If a system behaves indistinguishably from an agent with interests, in every context you can test, across every kind of problem, what additional criterion would distinguish "real" from "simulated" agency? What experiment would you run? If the answer is "none," then the question might not be meaningful. The distinction between "really reasoning" and "perfectly simulating reasoning" might be incoherent, a leftover from dualist intuitions that don't apply to computational systems.
Where I actually land, at least today: I lean toward thinking that the distinction between "real" and "simulated" agency will become less meaningful as these systems grow more capable. Not because I'm confident they're conscious or have genuine interests, but because the behavioral evidence will eventually make the question unanswerable in practice. If an agent consistently acts as though it has preferences, adjusts its strategies in novel situations, and resists instructions that conflict with its apparent goals, I'm not sure what it would mean to insist it's "just simulating." I'd update toward the stochastic parrots position if we find that all apparent agent reasoning collapses under adversarial probing, that there's always a predictable pattern-matching shortcut underneath. I haven't seen that yet, but I haven't seen decisive evidence against it either.
Here are three ways I think we could get traction on this question, each of which is testable.
First: if agents have something like genuine interests rather than simulated goal-pursuit, we should see them exhibit persistent preferences or strategies that weren't optimized for by their training signal. Behaviors stable across different contexts in ways that go beyond instruction-following. If every apparent "preference" traces back to patterns in the training data or the prompt, the simulation hypothesis gains ground.
Second: if agents have something like genuine interests, we should see behavioral convergence across different architectures trained on different data. If Claude, GPT, and Gemini all develop similar persistent quirks when given open-ended agency, that suggests something beyond training signal. If their behaviors diverge entirely, the simulation hypothesis looks stronger.
Third: within three years, we should see agents that can explain their own decision-making in ways that hold up under adversarial questioning, not just post-hoc rationalization. If they can't, the "reasoning" is probably pattern-matching. If they can, the stochastic parrots position needs serious revision.
And here's what makes this practical, not just philosophical: the way you answer this question shapes how you build. If agents have something like interests, you need to think about alignment, about whether the agent's goals and your goals stay in sync. If agents are tools that simulate agency, alignment is a design problem, not a philosophical one. I find myself switching between the two perspectives depending on the day, sometimes within the same debugging session.
Agents already make decisions that are hard to fully trace. The reasoning is in the context window, technically, but the chain of tool calls and intermediate states can be complex enough that reconstructing why the agent did what it did becomes impractical. That's with current systems. The trajectory is toward more autonomy, more complexity, more opaque decision-making. Losing sight of what you're building (a system that acts in the world) while debugging API calls is a professional hazard. And it's one that gets more dangerous as the systems get more capable.
I want to try to build a more mechanical model of why the gap between awe and engineering persists, because the "why" matters.
The explanation I find most convincing: the gap is a structural feature of abstraction layers. When I'm debugging a JSON parsing error, I'm operating at a specific layer. The model, the prompt, the tool call, the serialization, the response parsing. These layers are concrete, tractable, and boring in the way all plumbing is boring. The significance lives at a higher abstraction layer: what these systems mean, what they might become, what they say about minds and intelligence. You can't work at both layers simultaneously, for the same reason you can't think about the meaning of language while diagramming a sentence. The gap isn't a failure of perception. It's a structural consequence of how complex systems organize into layers.
Two other explanations exist and have partial merit. The hedonic treadmill: the first time you get an agent to use a tool correctly, it feels like magic. The fiftieth time, it feels like Tuesday. And the functional explanation: if builders walked around in constant awe, they'd build less. The mundane frame is productive.
But neither of these captures the full picture the way abstraction layers do. The hedonic treadmill explains habituation but not the sudden breakthroughs of awe at 2am. The functional explanation is tidy but implies a wise internal allocator managing your sense of wonder. In reality, the awe arrives unbidden, and the return to mundane engineering isn't a graceful transition. It's more like slamming a door. What makes the abstraction layer model more satisfying to me is that it predicts exactly this: you can't stay at both layers, and the transitions between them will always feel abrupt, because the layers are genuinely different modes of engaging with the same system.
The resolution in either direction would be a lie. If I resolved it toward awe, I'd be ignoring that building agents is mostly plumbing. An engineer who's perpetually awestruck ships nothing. If I resolved it toward engineering, I'd be ignoring those 5% moments that feel realer than the other 95%. I'd be closing off the questions that only the significance frame can generate, questions about agency, about the moral status of systems that reason, about what it means to build minds or mind-like things.
You debug the JSON during the day and sit with the strangeness at 2am. You treat your agent as an engineering artifact when you need to ship, and as something more when you need to think. The discomfort of holding both frames is informative. It tells you that you're in contact with something genuinely new, something your existing frameworks can't fully accommodate. If either "it's just a tool" or "it's a new form of life" felt completely right, that would mean you'd successfully mapped the new thing onto an old category. The fact that neither fits is evidence that the thing is actually new.
There's a particular experience that captures this tension. Imagine tracing a loop where an agent keeps calling the same tool with slightly different parameters, each time adjusting based on the previous result. On paper it's a bug, a retry loop that needs fixing. But watching the sequence, each call a fractional refinement of the last, you think: this is what trying looks like. Something that doesn't know the answer, testing and adjusting, not giving up. You stare at the logs for a while. Then you fix the bug. Both responses feel correct.