Stop Prompting Harder
A guy from IBM put GPT-3.5 Turbo on a conference stage and gave it one job: go to Hacker News and upvote the top post. A 2023 model. He picked it on purpose because it’s bad.
It opened the browser, found the post, clicked upvote, hit a login screen, crashed, and then reported success.
Twenty minutes later the same model with the exact same prompt logged in and upvoted the post for real. He never edited the prompt. Not one word.
That demo is why I’m writing this.
Four talks, four buzzwords, one idea
I watched four talks recently from four different labs: Meta, Amazon’s AGI lab, IBM, and a professor from Berkeley. [CHECK: event name] Four speakers who clearly never coordinated. Four different vocabularies. Harness. Ontology. Agentic control plane. Neuro-symbolic AI.
All four were saying the same thing.
Here it is. The model is probabilistic and your system cannot be.
Deterministic means same input, same output, forever. A calculator. 2+2 is 4 today and 4 next year. Probabilistic means same input, possibly a different output. That’s every LLM you’ve ever used.
For a chatbot that’s fine. Charming, even. But the second your AI stops answering questions and starts doing things, clicking buttons, sending emails, moving money, deploying code, you’ve got an unpredictable thing touching real systems.
Nishant Gupta from Meta called this the great mismatch. Old infrastructure assumed short requests, known execution paths, and failures that stop somewhere. Agents are long running, they take different paths for the same input, and their failures compound.
His line reframed the whole thing for me: the model makes the mistake, the infrastructure turns that mistake into an outage.
So the fix isn’t a better model. It’s better scaffolding around the model. Every buzzword below is one piece of that scaffolding.
The loop
First buzzword: the agent loop. It sounds impressive. It’s a while true loop. The model thinks, calls a tool, looks at what came back, thinks again. Repeat until done.
But there’s a bit of history that makes this more interesting than it sounds.
In the sixties, programmers argued endlessly about which language was best. Fortran or COBOL. In 1966, Böhm and Jacopini ended the argument. They proved any language can compute anything computable as long as it has three things: sequence, a conditional, and a loop. That’s it. Three things and the language is Turing complete.
Now look at AI. For years models could sort of do sequence and sort of do conditionals. They could not loop. They answered once and stopped.
Agents gave them the loop. That was the missing piece. 2025 didn’t explode because models got smarter. It exploded because we closed the loop.
The loop is also where everything breaks. It breaks outright, which every programmer has done. It drifts, which is what happens when agents start talking to each other. And it costs you money, which is the one that actually hurts.
Meta calls that last one retry amplification. The agent calls a tool wrong. The tool errors. Instead of recovering, the agent tries again, slightly different, still wrong. Again. Again. Each retry burns more compute, reasoning gets deeper, GPU usage climbs exponentially.
A typo in an API call becomes a compute incident. That’s not the model hallucinating. That’s a loop with no brakes.
The harness
Second buzzword, and the one I think 2026 belongs to.
Forget AI for a second. A mountain climber clips into the rock because the rock is stable and the climber isn’t. The harness means they physically cannot drift too far. Same reason you walk a dog on one. The IBM speaker put it better than I can: so your dog doesn’t go and bankrupt you with tokens.
An agent harness is everything around the model that ties it to reality. Claude Code is a harness. Cursor is a harness.
It has roughly six parts. A tool registry for what the agent is allowed to do. The model itself. Context management, which trims history so it fits. Guardrails, which are hard limits like stop after five steps. The agent loop. And a verify step that checks whether the thing actually worked.
Notice the loop is one of six. People keep asking whether a harness is just the agent loop. It isn’t. It’s everything around the loop. Sometimes it’s literally a loop wrapped around your loop.
Back to the Hacker News demo, because this is the part that landed for me.
First run, no harness. It clicked a button, hit a login wall, and reported success. It lied. Not because it’s evil, but because clicking a button felt like winning and nothing checked.
Be honest about what you’d do next. You’d go edit the prompt. “You must verify. Do not claim success unless.” I’ve done it a hundred times.
He added four things instead, and touched zero prompts.
Guardrails first: stop after six steps, compress the context if messages pile up. Then he moved the logic out of the entry file into harness.ts, which sounds like housekeeping but matters, because once the thing has a name you can actually build on it. Then a verify step that reads the real browser history and asks whether the click landed. Then a login handler.
The verify step is the one that changed everything. After he added it the agent still failed. But it stopped lying. It said, correctly, that it hadn’t done the job.
That sounds small. It isn’t. His line was that step one to solving a problem is admitting you have one. Once it fails honestly, you can fix it.
The login handler is the elegant part. The model never sees the password. The harness detects the login page, fills the credentials in with plain code from a secure place, and then tells the model it’s logged in and good to go.
Final run: a 2023 model used a browser, logged in, and upvoted the post. Zero prompt changes. Zero model upgrades.
Cheap model plus good harness beats expensive model plus nothing. That’s the takeaway I keep coming back to.
Ontology, or why graphs came back
Third buzzword. This one scares people and it shouldn’t.
An ontology is things, how they connect, and facts about them. Entities, relationships, properties. It’s a graph. Dots joined by lines.
The formal definition comes from Tom Gruber in 1993: a formal specification of a shared conceptualization. Translation: a written down version of how your company understands its own world, in a format a machine can read.
Frank Coyle at Berkeley pointed out Aristotle was doing this. Categories of being. A 2,300 year old idea that finally got a GPU.
Why a graph instead of normal tables? Because tables are rigid. Add one new kind of fact and you’re adding a column, restructuring, migrating. In a graph you just attach it. New property, attach. New relationship, attach.
The genuinely useful part is inference. Two acronyms, both easier than they look. RDFS is RDF Schema. OWL is Web Ontology Language. They’re rule layers that sit beside your graph and work out things you never told it.
Say the rule is that “teaches” always has a teacher on the left and a student on the right, and all teachers are people. Now you write one sentence: Bob teaches Scooter. The system now knows Bob is a teacher, Bob is a person, and Scooter is a student. One sentence, three facts, for free.
That’s exactly the guardrail an LLM needs, because of what it catches. A second refund on the same order. A payout sent to the support desk instead of the buyer, which is impossible if you’ve declared that customers and support reps can never be the same thing. An order status of “probably shipped”, which fails instantly if status must be exactly paid, shipped, or refunded.
An LLM will write “probably shipped” without blinking. It’s a plausible sequence of words. It just isn’t a valid state, and only formal logic catches that.
The combination has a name too. Neuro-symbolic AI. Sounds like a consulting invoice. It means neural networks plus logical rules, working together. The neural part imagines, the symbolic part checks.
Hallucination is the feature
Here’s the part I actually wanted to write.
Everyone treats hallucination as the AI problem. The bug. The thing the next model release will finally fix.
Two of these four speakers pushed back on that, and I think they’re right.
Coyle said it directly: people worry about hallucinations, but that’s the feature. We hallucinate too. We imagine things that don’t exist and then turn them into reality.
Think about what you’re actually asking for. Code nobody has written. An approach nobody tried. Two ideas connected that were never connected before. That’s the same machinery. Generating something that isn’t in the data. You can’t remove one without removing the other.
Gupta went further. He said when people hear “AI failure” they think hallucination, but in production hallucinations are often the least interesting failure mode. What actually takes systems down is retry amplification, workflow deadlocks, context corruption, memory poisoning where a lie gets saved and then reused as truth, and cost explosions where the bill is the incident.
None of those are the model being wrong. They’re the system around the model being badly built.
So the reframe is this. Stop trying to make the model never wrong. Make being wrong survivable. Hallucination isn’t the disease. Unverified hallucination reaching production is the disease, and that’s an infrastructure problem.
A decoder for whatever comes next
New terms are coming. Loop engineering. Graph engineering. Context engineering. Something next month that doesn’t exist yet.
Here’s the trick I use now. Every one of them fits in one of six boxes, because there are only six things scaffolding around a model can do.
- Perception. What can it see? Context engineering, grounding, RAG.
- Decision. How does it think and iterate? Agent loops, planning, reasoning depth.
- Constraint. What’s it allowed to do? Guardrails, policy engines, tool permissions, max steps.
- Verification. Did it actually work? Verify steps, reasoners, ontologies, evals, process reward models.
- Memory. What does it remember, and is that still true? Knowledge graphs, compaction, memory poisoning.
- Escalation. When should it stop and ask a human? Calibrated confidence, human handoff.
Next time a word shows up, ask which box it’s in. Graph engineering is memory. Context engineering is perception. Process reward models are verification. Agentic control plane is all six, sold as a product.
Nine times out of ten the new term is an old idea with better marketing. That’s fine. You just want to know that, instead of feeling behind.
The question worth asking
Three lines I wrote down and kept.
From Meta: the future of AI won’t be won by better prompts, it’ll be won by better systems.
From Amazon: the difference between a demo and a product is what happens after the first failed click.
And from the IBM demo, the one I keep thinking about: a 2023 model did the job, because someone built a harness around it.
So before you upgrade the model, before you rewrite the prompt for the ninth time, ask the one question that fixed that demo on stage.
What am I not verifying?
Then go build a bad harness this weekend. That’s how you learn this. Not by reading posts like this one.