.webp)
Jensen Huang has repeatedly made this observation…traditional computing was largely pre-recorded.
Software contained fixed sequences of instructions…algorithms and recipes that humans wrote in advance.
The computer’s job was to execute that recorded logic reliably against structured inputs.
Outcomes were (mostly) deterministic. When something went wrong, you could
usually reproduce the exact path, identify the deviation, and apply a targeted correction.
That model has served us extraordinarily well for decades.
Agentic AI systems break it.
When an application is no longer a pre-recorded sequence but a generative process…where large language models reason, plan, call tools & produce outputs in real time based on context and intent, several things change at once.
The same prompt and tools can yield different trajectories on different runs. Small variations in early reasoning can cascade into entirely different plans or tool selections.
“Correctness” often becomes multi-dimensional and goal-oriented rather than binary:
Did the agent achieve the intended outcome efficiently?
Did it stay within acceptable bounds? Was the cost reasonable?
In this world, traditional notions of bugs become fuzzier.
Many failures are not simple deviations from a spec but emergent behaviours: poor decomposition, brittle tool use, context drift, or inconsistent performance across slight input variations.
Reproducing a failure exactly is harder. Defining a crisp “fix” is harder still.
This is why hill-climbing, or more broadly, evaluation-driven iterative optimisation, becomes central to building robust agentic systems.
Instead of only debugging individual execution paths, you instrument rich observability, define meaningful success metrics…
- task completion,
- trajectory quality,
- efficiency,
- safety,
- user preference
and treat the current configuration of prompts, tool descriptions, routing logic, memory strategy and control flow as a point on a performance landscape.
You then make deliberate changes, re-evaluate (often across multiple runs to account for stochasticity) and keep what moves the metrics in the right direction.
It is closer to machine learning engineering than classical software engineering.
I would say frameworks like DSPy formalise parts of this loop. Even without them, teams are increasingly running systematic experiments: clustering failure modes from traces, testing prompt or architectural variants, and using the resulting signal to climb toward better performance.
Of course, this doesn’t mean we should abandon determinism where it helps. Structured outputs, explicit graphs (as in LangGraph), verification steps and guardrails remain valuable.
The art lies in knowing where to keep tight control and where to allow generative flexibility.
The deeper shift Jensen points to is that we have moved from retrieving pre-recorded intelligence to generating contextually relevant responses on demand.
That change ripples through every layer…how we design systems, how we evaluate them, and how we improve them over time.
For builders working on real agentic applications today, the practical question is no longer just “Does this work on the happy path?”
It is: “How do we systematically get better at this, even as the underlying behavior remains probabilistic?”
That question is shaping a new discipline. And the teams that learn to climb these hills effectively will ship systems that actually deliver on the promise of agentic AI.
Hill climbing only works if you can do three things well: observe where you are on the performance landscape, change one variable deliberately, and re-measure and this is precisely what Kore.ai's Artemis platform is architected for.
Because agents are defined in Agent Blueprint Language (ABL), a typed, schema-driven language where behavior, tools, guardrails, orchestration, and handoff logic are expressed formally, the "current configuration" of an agentic system stops being a diffuse tangle of prompts and glue code and becomes an explicit, versionable, compilable point on that landscape one you can mutate, diff, and roll back with the discipline the post calls for.
The evaluation loop itself is built in: Arch, the platform's AI agent architect, continuously refines agents using real-world production traces, which is exactly the "cluster failure modes from traces, test variants, keep what moves the metrics" cycle described above, but formalized at the platform level rather than bolted on per project.
