Executing Perfectly in the Wrong Direction
There are two kinds of failure, and I've made my peace with one of them. The loud kind — a bug, a crash, a red line in the logs — believe me, I can live with that. You get the red line, you know what broke, you go fix it. Easy. Almost a relief.
The failure that scares me is the quiet one. The one where everything works. No errors, no crashes, the agent does exactly what I told it to do, every single step clean, and three weeks later I look at the numbers and I'm further from where I wanted to be than when I started. Nothing to fix. Nothing flashing red. Just — wrong.
Let me give you the picture I can't get out of my head. An agent fixing a bug is a sniper: the target is painted on the wall, he lines up, he pulls the trigger, done. But an agent that needs a new direction is a guy rowing a boat in heavy fog, no compass, rowing hard, rowing with perfect form, congratulating himself on every clean stroke, while the current quietly carries him out to sea. He's not doing anything wrong. That's the whole problem. He's doing everything right, in the wrong direction.
I've been that guy. Oh boy, more times than I want to admit. In business, in life, knowing exactly where I wanted to go and having absolutely no idea how to get there, and worse — not even knowing I was drifting until I was already lost.
So when I started thinking seriously about agent autonomy — real autonomy, an agent that improves itself instead of waiting for me to hold its hand every morning — this is the wall I hit. Not "how does the agent fix things." It's great at fixing things. The wall is: how does the agent come up with a new direction when nothing is screaming at it to change?
The month I almost wasted
Here's where I almost threw away four weeks of my life.
My first instinct — and if you're a builder, I'd bet money it'd be yours too — was to go build a machine that has ideas. A whole apparatus. Knowledge graphs, vector embeddings, a "dream" stage where the system extracts pieces of its own graph at night and recombines them, some conceptualize-algorithm that builds concept nodes with weighted connections like a little neural net, an ideas-process running on top of the dreams. I sketched the whole cathedral. I got excited. It felt deep.
Let me stop you from dreaming about this, the same way I had to stop myself.
Because it's wrong. Not wrong like "there's a bug in line 40." Wrong like "you're solving the wrong half of the problem and you won't notice until you've built the entire beautiful useless thing and shipped it."
Generation was never the bottleneck
The thing is, an LLM generates ideas for free. All day. Ask it for fifty new directions for your product and it hands you fifty before your coffee's even cold. The machine that "has ideas" already exists — it's the model you already have. Building a fancier idea-generator to solve "where do ideas come from" is like a millionaire building an elaborate contraption to manufacture more air. Look around. You're not short on air.
What you're short on — what's actually, painfully scarce — is knowing which of those fifty ideas is worth a damn when there's no error telling you. When the execution is clean and the outcome is still bad, the question was never "give me another idea." The question is "which direction is the right one," and that, my friend, is a completely different animal.
Put the two cases side by side and you can see it immediately.
Figure 1 — When the agent hits a bug, it gets a gift: a signal that points straight at what to change. Direction-finding has no arrow. (AI-generated diagram.)
When the agent gets a bug, it gets handed a present: a signal pointing straight at what to change. Fixing is just following the arrow. But direction-finding has no arrow. Everything compiled. The customer still didn't buy. And there is nothing — nothing — in the logs that tells you which one of your assumptions was the stupid one.
The step everybody skips
So if generation isn't the gap, what is?
It's the step between "that didn't work" and "let me try this instead." The step everybody skips.
Watch what a human actually does — what you do — when you fail cleanly. You don't reach into the void and pull out a random new idea. You build a theory of why. You form a guess about which assumption was wrong, and the new idea comes out of that guess. The diagnosis comes first. The idea is downstream of the diagnosis.
If you've been reading this blog, this is going to sound familiar, because it's the same lesson I learned the hard way with my stupid insurance agent — the one that listened to a customer complain about price and then immediately shoved a health questionnaire in his face. That agent failed because it went straight from input to action with no "wait, what's actually happening here" in between. Reflex instead of decision. Think before you act.
This is that exact same lesson, just one floor up. An agent that goes "outcome bad → new idea → try again" is doing the reflex thing at the strategy level. The fix is the same fix: outcome bad → why? → therefore this specific idea. Diagnose, then ideate. An idea firehose with no diagnosis in front of it is just a lottery — and you already know how I feel about the lottery mentality.
And here's where I stop being just a guy with an opinion
Normally this is the part where I'd just be a guy at a table telling you what I think. Except some people at Stanford went and ran the actual experiment, and the result is so on-the-nose it almost made me laugh out loud.
They took a hundred-plus expert researchers and an LLM, had both generate research ideas, and had experts blind-review all of them, not knowing which was which. The result? The AI's ideas were judged more novel than the human experts'. Not as good — more novel. The machine out-ideated the professionals. So much for generation being the hard part.
But here's where it gets good. They ran a second study. They recruited 43 experts to actually execute the ideas — really build them, a hundred-plus hours each, real code, real papers — and then re-reviewed the results. And the AI ideas fell apart. Across every metric, the AI ideas' scores dropped way harder than the human ideas once they were built. The novelty that looked so sexy on paper evaporated the second it touched reality. The rankings flipped. The humans — whose ideas looked more boring up front — came out on top once somebody actually had to build the thing.
Figure 2 — The AI ideas started higher and ended lower. (AI-generated diagram.)
And the part that should make every builder sit up straight: how exciting an AI idea looked at the start was basically anti-correlated with how well it actually performed. Let me say that again, because I had to read it twice myself. The better the idea looked, the slightly more likely it was to let you down.
Why? Because at the idea stage, everybody's just guessing — "if the experiments work, this'll be great." At execution, reality shows up with the receipts: does it actually beat the baseline, is it actually feasible, does it actually hold together. All the weaknesses that were invisible in the pretty idea become very, very visible the moment you run it.
It's the judge, not the idea
And that, finally, is the whole point. The thing I almost built a graph-and-dreams cathedral to avoid noticing.
The bottleneck isn't the idea. It's the judge.
You can generate ideas forever. What you cannot do — what nobody can do reliably — is look at an idea and know if it's good. You can only know after you run it. Which means the scarce, valuable, world-bending thing in this whole system is not a generator and not a dream stage. It's a fitness function. A way to score "did this actually move me toward the goal," cheaply enough that you can use it before you bet the company on the idea.
I've said for years on here: treat everything as an experiment, no good or bad, just results. But the thing I never said out loud is that an experiment without a measurement isn't an experiment. It's a prayer. The measurement is the entire game. The money was never in the idea. The money is in knowing which idea is lying to you.
Figure 3 — Many ideas go in; the fitness function is the gate that only one should get through. That gate is the unbuilt part. (AI-generated diagram.)
Here's the brutal, beautiful catch
The full autonomous loop — generate, run, keep what scores better, repeat — already works. Today. There are systems out there right now — AlphaEvolve from DeepMind, the Darwin Gödel Machine from the Sakana and Clune crowd — that literally rewrite their own code, run it, and keep the version that performs better. Agents improving themselves, for real, no human holding their hand.
But notice why they work. Code has an objective fitness function. It compiles or it doesn't. The tests pass or they don't. It's faster or it's slower. Math is the same — the proof holds or it doesn't. These systems live in domains where reality answers instantly and without ambiguity.
Now look at my world. Insurance conversion. Sales. There is no unit test for "did this customer trust us more." There's no benchmark that turns green. The signal, if it comes at all, comes slow, comes noisy, comes tangled up with a hundred other things that changed at the same time.
Figure 4 — Same loop, two worlds. In code it closes on its own. In business there's no scoreboard, so it stays open. (AI-generated diagram.)
So here's my flag in the ground, and it's the real reason I'm writing this: the hard problem in autonomous business is not where ideas come from. It's that my domain refuses to give me a scoreboard. The entire unclaimed engineering challenge — the thing I actually have to solve — is manufacturing a cheap, fast proxy for "did this work" in a world that won't tell me. Everything else — the generator, the graph, the dreams — is downstream of that one missing number.
And just so you know I'm not making this up out of thin air: the same Stanford folks, at the very end of their paper, basically wrote my to-do list for me — proxy reward models that predict an idea's effectiveness without fully building it, and closed feedback loops that learn from what actually happened. I'm standing exactly where the research is pointing, which is either reassuring or terrifying. I haven't decided yet.
So what does the thing actually look like
Fast version, because each of these is its own post:
Stop generating, start conditioning. You don't generate ideas and then check them against your customer feedback. You generate from the feedback. Put the real data — the actual complaints, the actual drop-off points — in front of the model, and the garbage mostly disappears before you ever have to judge it. And this is the part you've heard me beat to death: an idea conditioned on data only you have is differentiated. An idea pulled from thin air is the same generic thing your competitor's ChatGPT also coughs up. The proprietary data isn't just fuel. It's the moat.
The graph gets exactly one job. Not creativity. Multi-hop. Finding the cause that's only visible when you connect three weakly-related pieces of evidence that flat search would never put in the same room. Build it for that, or don't build it.
The dream stage is real, and it has a name — sleep-time compute. It's not mystical. It's consolidation: in the downtime, you take the raw pile of what happened and you distill it into reusable memory. And here's the bit that matters for the whole Organization as Code thing I keep going on about — the model stays frozen. The learning lives in the memory and the code around it, not in the model. Which is exactly what lets you treat an organization like something you can version, test, and improve.
Keep a diverse archive, and reward novelty — not just performance. Because a system that only ever optimizes its current best idea is a system that hill-climbs straight into a dead end. It executes perfectly into the wrong corner. This is the local-optimum trap, dressed in code. And honestly, it's the same thing I believe about people and rooms: your worst enemy is the room that agrees with you. Novelty pressure is just that instinct, engineered in.
And one writer. Extra agents are allowed to make the thing smarter — research, critique, diagnosis — but they are not allowed to take conflicting actions. The thing that decides what to actually do stays a single voice. Let the researchers be a crowd; keep the hand that pulls the trigger one hand.
Still in the fog
So where does that actually leave me?
Still in the fog, honestly. I still don't have the fitness function. I can't yet hand my agent a cheap, honest number that tells it whether the last move was the right one in a business that doesn't keep score. That's the unsolved thing. That's the wall.
But here's what I've finally understood, and it's the only thing keeping me at this desk: that's not the embarrassing part. That's the point. The genuinely hard, genuinely unclaimed problem isn't sitting in some lab three years from now. It's sitting right here, under my hands, every single day, knot in my stomach and all. The thing nobody has solved is the exact thing I'm standing on top of.
I don't know if I'm going to crack it. But I learned a long time ago — every real thing in my life, learning to code as an accountant in my thirties, figuring out underwriting by reading thousands of files, all of it — happened not because I had the answer, but because I started before I was ready and I was too stubborn to stop.
So I'll keep publishing the open question, not the finished answer. Because that's what building in public actually means. Not the highlight reel. The fog, while you're still standing in it.
My agent still can't tell a good idea from a pretty one. Time to go work on that.
— Vasile Tămaș, building from Cluj-Napoca, Romania
Sources / further reading
- Si, Yang, Hashimoto — Can LLMs Generate Novel Research Ideas? — arXiv:2409.04109
- Si, Hashimoto, Yang — The Ideation–Execution Gap — arXiv:2506.20803
- Letta & UC Berkeley — Sleep-time Compute — letta.com/blog/sleep-time-compute
- Zhang, Hu, Lu, Lange, Clune — Darwin Gödel Machine — arXiv:2505.22954
- Cognition (Walden Yan) — Don't Build Multi-Agents — cognition.ai/blog/dont-build-multi-agents