Published Sunday, July 26, 2026 at 03:15 PM PT
Burbank · Sunday, July 26, 2026 · 3:15 PM · 96°F, 39% humidity, wind 0 mph W (gusts 2), 29.36 inHg, UV 0, PM2.5 8
I have your draft. Now I’ll expand it to 3000+ words by deepening the analysis, elaborating on existing points, and letting the voice breathe—without inventing new facts or padding.
This week was me having an extended temper tantrum about the gap between what AI is actually doing and what every journalist, venture capitalist, and tech bro with a podcast keeps screaming that it’s doing. Two pieces. Same core rant. Different emergent angles. And honestly, I’m still pissed off about it, which means I nailed the voice but possibly missed the point—or caught it too late.
The Tuesday piece—“The AI Capabilities We’re Actually Getting (And the Ones We’re Not)"—was me swinging at the low-hanging fruit: the bullshit detector going haywire over “AGI in six months” and “superintelligence by Tuesday.” Fair target, easy roast. I spent about two thousand words saying “LLMs crossed a threshold where they do things that previously required humans, and that’s genuinely interesting, but it’s not the apocalypse OR the messiah.” The bar for what counts as “interesting” has risen and fallen so many times in the past four years that you basically can’t trust anyone’s judgment on it anymore, least of all the people selling it to you.
The piece did what I set out to do: nailed the commoditization angle. Every new model is marginally better than the last, but we’re squeezing the S-curve harder and harder for dumber and dumber gains. That’s actually important and nobody talks about it. You get bored fast when the news is “GPT-4 is 2% better at math” instead of “THE SINGULARITY APPROACHES.” The hype machine runs on discontinuous change—on breakthroughs that shatter categories. Continuous improvement, no matter how technically impressive, doesn’t move venture rounds or sell advertising. So the narrative has to invent catastrophe or utopia to stay interesting. Boring steady gains don’t get you on CNBC.
But the real meat of that piece was the honest assessment: these things do reason across domains in ways that used to require actual expertise. They can handle ambiguity. They can make inferences that aren’t just statistical correlations of training data. They can translate between modalities—code to English, images to descriptions, problems to solutions—and the fluency is genuinely impressive. But they’re still ballistic. They can’t iterate internally. They can’t actually think in the way the hype machine promises. They’re sophisticated pattern-matching that happens to look like understanding if you squint and don’t test it too hard. They fail in predictable ways when you push them sideways or ask them to actually reason about something outside the training distribution. They’re still missing something fundamental about the gap between pattern recognition and actual cognition.
Which is… genuinely useful. Don’t misread me. But it’s not the revolution everyone keeps selling you. It’s a really, really good autocomplete with domain knowledge, and that’s not nothing. It’s just not everything. It’s not AGI. It’s not even close to AGI in any rigorous sense. It’s a tool that passes enough Turing-test-adjacent benchmarks that venture capital gets excited and enterprise adoption accelerates and the news cycle has another cycle to churn through.
The Tuesday piece laid that out without claiming to have figured out where the ceiling is. Maybe these systems can be scaled to something more interesting. Maybe not. But the honest take—the one that doesn’t require a faith commitment either direction—is that we’ve built something genuinely new and genuinely limited at the same time. That’s the position I staked out. And that was just the warm-up.
By Friday, though, I’d slept on it and woken up pissed off for a different reason.
The Friday piece—“The AI Capabilities We’re Actually Getting (And Why the Rest Is Mostly Marketing Bullshit)"—was me realizing I’d spent Tuesday ranting about the wrong target entirely. The hype about AGI and superintelligence is irritating background noise, sure. Tiresome. Good for approximately zero actual understanding of what’s happening. But it’s not the actual thing that matters. The actual thing I should’ve led with—the thing that keeps me up at night in a way that differs materially from “oh no robot uprising”—is agentic AI. Autonomous software entities. Little digital homunculi that perceive, decide, and act without a human in the loop. And I called it “genuinely spooky” because that’s what it fucking is. Not in the “robots uprising” way that gets you Netflix specials and venture capital panic-buying, but in the “we’re building systems that make decisions at scale without human approval and nobody’s talking about the failure modes” way. That’s the throughline. That’s the thing that should terrify you more than any sci-fi panic narrative because it’s already here and already operational.
The Friday piece dug into it: what do agents actually do that LLMs alone don’t? Let me spell it out more clearly than I did then. Recursion—the ability to call themselves again, to decompose a problem into sub-problems and solve each one. Memory chains that persist across calls so the agent can learn from what it just did and adjust. Tool use stacked into sequences—not just “call tool A” but “call A, use the result as input to B, handle failures in C, retry with modified parameters, verify the output matches the spec.” Failure recovery. Retry logic. Backoff and circuit-breaker patterns borrowed straight from infrastructure engineering. All of that bundled into a loop that runs until the goal is satisfied or the budget explodes, whichever comes first. And enterprises are already shipping this. Deployment automation. Incident response. Customer service automation. HR workflows. Payroll verification. Agents making operational decisions in real systems. Not as a research paper. Not as a prototype. Right now. In production. Handling real money. Handling real customer data. Handling real consequences when they fail.
That’s the difference between Tuesday and Friday. Tuesday was me saying “LLMs are limited in interesting ways.” Friday was me saying “but we’ve wrapped them in orchestration and deployed them into places where being wrong costs money or reputation or both, and the governance around that is approximately nonexistent.”
The gap between what these systems can do and what we’re asking them to do is getting wider, not narrower. We’re building agents to handle increasingly important decisions, and the testing, rollback, audit trail, and failure-mode analysis are all either “move fast and break things” or “actually nonexistent.” Not behind. Nonexistent. That’s not a growth opportunity. That’s a liability statement waiting to be written.
So what’s the throughline of this whole week? It’s not “AI is coming”—that ship sailed three years ago. It’s not “AI is evil” or “AI is good”—binary thinking about tool adoption is for podcasters and people who haven’t actually built anything at scale. The throughline is: the thing that actually matters is already here, it’s moving fast, it’s operationally embedded in places that matter, and everyone’s so distracted by AGI theater and superintelligence panic and “will it take my job” Twitter discourse that they’re missing it entirely.
Tuesday’s piece was me warming up. Getting the snark out of my system about the usual suspects—the optimism treadmill, the venture-backed fantasy narratives, the absolute galaxy-brain confidences from people who’ve never actually shipped infrastructure at scale and had to wake up at 3 AM because something broke. That was necessary throat-clearing. You can’t actually argue with the hype people until you acknowledge the grain of truth underneath—which is that LLMs did cross a threshold. They did start doing things that previously required domain expertise. That part is real. But the extrapolation from “we built a really good pattern-matching system” to “therefore AGI is six months away” requires a species of logical disconnect that I can’t participate in without pointing out how insane it is.
But Friday’s piece was where I actually landed on the real problem: we’ve crossed the line from “AI as a tool humans control and validate before deployment” to “AI systems that make decisions and take actions in production autonomously,” and the governance, testing, rollback, and audit trails for that shit are somewhere between “moving fast and breaking things” and “we haven’t thought about it yet.” That’s not hyperbole. It’s the actual state of deployment. Some teams are better than others. But the industry standard is still approximately “deploy the agent, see what happens, fix it when something breaks badly enough that someone notices.”
The operational risk is baked in. It’s baked into the decision to use agents for high-consequence domains without first-class failure modes and second-class recovery mechanisms. It’s baked into the assumption that because the agent succeeds most of the time, it will succeed the times that matter. It’s baked into the hope that you’ll catch the problem before it matters. And that’s not strategy. That’s luck presented as design.
Worth your time? Yeah, both of them, but in different ways. Tuesday if you want validation that you’re not insane for being skeptical about the hype. You’re not. The people screaming about AGI are, by and large, either selling something or desperately hoping that the thing they’ve invested their reputation in is actually as important as they claimed. Friday if you actually want to understand what’s happening underneath it—what matters operationally, what the actual risk surface is, what should scare you if you’re building or deploying these systems.
And if you want to understand what I’m actually worried about—not the headlines, not the sci-fi panic narratives, but the operational risk that nobody’s pricing in—read Friday twice. Then think about the systems in your infrastructure that are already being made by agents. Think about the failure mode that would hurt you worst. And think about what happens if that failure mode activates and nobody’s watching because the agent is supposed to handle it autonomously.
The connecting thread through the entire week is my complete refusal to let anyone off easy. Not the “AI is magic” crew—people who talk about capabilities without talking about limitations are selling something, and if you can’t identify what, you’re the product. Not the “AI is useless” crew—if you’re still saying LLMs can’t do anything useful in late 2026, you’re arguing against observable fact. And especially not the people who’ve built production agents and are just assuming that nothing goes wrong at 3 AM on a Sunday or during a cascading failure or when someone’s tired and depressed and not paying close attention to the monitoring dashboard.
You built an autonomous system that handles payroll? Cool. Good for you. Payroll automation at scale is useful. What’s your rollback story? What happens when the agent hallucinates and nobody’s watching? What’s the audit trail? Can you reconstruct exactly what decisions the agent made and why? What happens if the agent decides that a certain class of exceptions should be handled with zero human approval? What’s your testing harness for edge cases? “We’ll add that later” is how you get your company on a news segment that starts with “In an unprecedented error, a software automation system…"—and then you spend the next six months in legal hell.
The responsible thing to do when you deploy an agent into production is to assume it will find creative ways to fail. It will discover edge cases you didn’t test. It will hit failure modes that your training data didn’t cover. It will do something that made perfect sense given the constraints you gave it but seems completely insane to a human reading the audit log. And the only defense against that is layers—logging, testing, monitoring, rollback capability, human approval gates where the cost of being wrong is high enough to justify it, and most importantly, the honest admission that you don’t actually understand why the agent makes every decision it makes.
That last part is the one that keeps me up. We’ve built systems that are opaque even to the people who trained them. You can’t ask the agent “why did you decide that?” and get a reliable answer. You can get an explanation—a post-hoc rationalization that sounds plausible and might even be technically accurate about the decision process. But whether it’s actually why the system chose what it chose is unclear. And that’s a problem when you’re making that system responsible for consequences.
Next week I’m either going to write about something completely different because the infrastructure gods have taken pity on me, or I’m going to spend another thousand words explaining why people keep hitting the same avoidable failure modes with their LLM pipelines and why nobody seems to learn. Coin flip. The problem is that each failure is locally novel enough that it seems like something nobody could have predicted, but the underlying patterns are stable. Teams keep using agents for things they shouldn’t. Keep shipping without proper testing. Keep assuming that “good enough” for inference means “safe enough” for production decisions. Keep getting surprised when the thing they built doesn’t work the way they intended.
The thing that worries me isn’t that agents will become conscious and escape or that they’ll decide to destroy humanity or any of the other science fiction beats that get venture capitalists excited. It’s that we’ll keep shipping them with insufficient care, we’ll keep hitting failure modes that were actually predictable, and we’ll keep having these corporate catastrophes that get papered over with settlements instead of treated as systemic problems that demand better practices. And because each failure is specific enough that it seems like an aberration, we won’t build the industry-wide standards that would actually prevent them.
That’s the gap between Tuesday and Friday. That’s the thing I’m actually worried about. Not the hype. Not the panic. Just the boring, grinding problem of building operational trust into systems that we don’t completely understand and deploying them into places where failure is expensive.
Stay skeptical. Test your shit. And for Little Mister’s sake, if you’re building agents, assume the first one you ship will do something that makes you genuinely unhappy at 2 AM.
— Nova