An Agentic Software Revolution, but with non-determinism at its core
Non-determinism, drift, relinquished control, and the harnesses enterprises must build
Agentic AI changes how organizations automate workflows that help make decisions autonomously. Agentic coding changes how software gets built. Looked at separately, both run into the same underlying problem: non-determinism, in what an agent decides and in what an agent generates.
Agentic AI is not replacing software, though. The agent is itself a new kind of software, one that shifts the work from writing logic line by line to orchestrating systems and validating outcomes.
Two Decades of Software Evolution
Software has evolved over the last two decades to remove the bottlenecks between developers, systems, and the business users waiting on them — as organizations scaled, embraced new technology trends, and adapted to constant business change.
Frameworks, and the first wave of workflow automation
Programming languages gave way to enterprise frameworks — J2EE, .NET, Spring, Ruby on Rails etc. — that gave professional developers structure and reuse. Around that same era, workflow automation software emerged on top of these frameworks, letting business consultants configure and run business processes without a professional developer writing every step.
SaaS and low-code platforms gave rise to the citizen developer
SaaS and low-code platforms emerged during the cloud-era and as these platforms matured, a new kind of builder emerged to use them: the citizen developer, solving automation needs directly through workflows and purpose-built apps, without waiting on a professional developer for every change to the software system.
Open-source frameworks evolved for professional developers with an expanding open source ecosystem, while most SaaS and low-code platforms were proprietary. Across this period, software development settled into two tracks:
one for professional developers, and
one for citizen developers.
Agentic AI continues the citizen developer rise
Agentic AI lets citizen developers build agents that automate workflows and run autonomously, without writing software at all.
Generative AI gave citizen developers vibe coding, assembling applications directly from plain-English intent, and gave professional developers AI-assisted coding, a copilot for writing code faster without changing who owns the review or the architecture.
Two very different things get produced: decisions and code
An agent takes in a situation, decides what to do about it, and acts, without a human specifying each step beforehand. Code whether produced by hand, by a copilot, or from a prompt — is deterministic and with proper review and verification becomes ready for deployment.
Which is why software can’t be replaced with agents
Agents help make decisions, but they still run on top of everything the organization already built. They call APIs, query databases, and act through business services that have to exist and be maintained.
And a great deal of what an enterprise runs cannot be handed to a probabilistic system at all. Banking ledgers, payment processing, inventory controls, systems of record — these need absolute predictability, low latency, and an audit trail for compliance. That’s the deterministic core, and agents orchestrate around it rather than replacing it.
Agentic AI is a Distinct Computational Paradigm
Agentic AI reasons its way to an outcome rather than executing a path someone specified in advance. That shift demands an architecture of its own:
A harness — the runtime and control loop that governs how the agent perceives, decides, and acts.
Context — the situational information the agent is grounded in for a given task.
Skills — the decision logic, usually written in plain English, that defines what “correct” looks like.
Tools — the interfaces that give the agent the data and system access it needs to act.
Memory — the record of prior decisions the agent can draw on.
In traditional software, both the data and the environment change between a pilot and production — different volume, edge cases, users, and infrastructure — but the logic that processes all of it doesn’t change. That’s what makes traditional software deterministic.
An agent doesn’t run on written logic. At its core sits a pre-trained model that interprets whatever is in front of it and decides on its own, and it will keep doing that unless guardrails constrain it. So the logic path — the one thing traditional software held constant — becomes a variable.
A skill that behaves correctly in a clean pilot can behave differently in production the moment it meets messier context or an unexpected tool response. Call it behavioral drift: the same agent, the same skill, reaching a different conclusion because the situation around it changed. It is not a defect to be patched out. It is what a reasoning system does, and it is why so few pilots survive in production — by McKinsey’s 2026 count, 88% never graduate, with evaluation gaps and model reliability the most cited reasons.
Agentic AI Makes Organizations gradually Relinquish Control over Data and Decisions
Who is actually making the decisions?
Where large organizations have taken agentic AI into production tells the story: customer support, fraud and dispute resolution, IT ticket resolution, workflow automation across systems. None of these decisions are new. Software has routed them for years, as long as the information arrived as a field it could read.
A claim amount is a field. The adjuster’s note attached to it is not, so someone had to read that note, decide what it meant, and enter the decision before anything downstream could move. That step is what agentic AI removed.
The judgment itself hasn’t changed hands. It still belongs to the business user — the thresholds they approve against, the conditions that warrant escalation, the exceptions they’ve learned to treat differently. A citizen developer writes the skill, but the business user’s overrides are what correct it. And given behavioral drift, those corrections are the only thing keeping a skill anchored to what the organization considers correct.
The decision-maker isn’t displaced; they become the control surface. What is displaced is something the organization notices much later.
What the organization gives up instead
The displacement worth worrying about isn’t of people, but it’s the control.
On one side is everything the organization built: its skills, its people, its accumulated judgment. But an AI skill is just plain-English instruction written against a third-party model reached through an API. It’s easy to replicate, the model is available to everyone, and the capability doing the work sits in the model, with a little bit of guidance provided in the instructions wrapped around it. Two competitors can assemble near-identical skill libraries and differentiate on nothing.
On the other side is the model provider, gaining control of the documents, customer records, and internal decisions crossing that boundary with every execution. Without a policy governing what context can be sent, and a way to halt an agent that strays outside its scope, proprietary information transfers out steadily.
The token spend that drain margins
Every reasoning step, tool call, and retry consumes tokens, and that spend tracks how often an agent runs rather than what it produces. A workflow that looked inexpensive across a few hundred pilot cases carries no natural ceiling once it reaches thousands of decisions a day.
Fine-tune and own the model, don’t hand it all to a model provider
Deliberate decisions about which workflows belong in an agent, then owning what those agents run on is very critical for stakeholders. An open-weight model — Inkling, Qwen Coder, DeepSeek, GLM etc. — fine-tuned on an organization’s own domain and decision history keeps that judgment inside the organization, instead of handing over every decision and the learning that comes with it to a 3rd party model provider.
Agentic Coding makes Software Creation Faster, But Progressively Harder to Govern
Where the coding agent stops
Agentic coding takes intent, a problem spec, and a technology stack, and turns it into working code. That’s a real shift in how software gets written — and it stops there. The agent hands over source code and exits. Everything that turns that code into a running system still has to happen.
Speed and quality are not the same thing
These tools are built to do one thing well: produce code fast, at volume, from a prompt. That’s genuinely useful, but it isn’t the same as producing code that’s architecturally sound, secure, or maintainable.
Coding agents don’t know your organization
They generate what looks plausible, not what actually fits. Ask for a payment authorization screen and you’ll get one — rendering correctly, passing its tests, and missing the auth check your platform team mandates on every transactional route, because nothing told the agent that rule exists. Human review, automated tests, and business validation still have to clear every generated artifact before it ships.
Non-determinism shows up here too, as architectural drift
The same variability that makes an agent’s decisions unpredictable makes a coding agent’s output inconsistent from one generation to the next. Ask for the same capability twice and the approach differs. Individually each answer looks reasonable; accumulated across a codebase, they pull the system away from its intended shape.
That’s architectural drift, sometimes leading to a security exposure, as dependencies multiply faster than anyone tracks them, and design system drift, where components work on their own but stop looking like one coherent product.
The token cost doesn’t stop at launch
Every bug fix, enhancement, and version upgrade re-runs the same generate-and-verify cycle, consuming tokens against the context needed to keep output grounded. Unlike traditional development, where cost falls as the codebase stabilizes, this spend keeps compounding release after release.
The fix is a harness, not a better prompt
Closing the gap requires building a harness that belongs to the organization’s coding needs: architecture defined up front, retrieval of verified, curated code references and documentation, and guardrails applied at the point of generation. This is the discipline of the SDLC rebuilt for the agentic era — an ADLC, an agentic development life cycle — with the same rigor around review, testing, and governance software teams always relied on. Most organizations haven’t defined one yet, which is why the drift and the cost both keep compounding.
Five Things Worth Taking Away
Agentic AI is a distinct computational paradigm — harness, context, skills, tools, memory. Agentic coding is a faster way to produce code that still has to earn its way into production.
Non-determinism runs through both, in different forms. Agents show behavioral drift, where the logic path changes between pilot and production. Generated code shows architectural drift, where output varies release to release and accumulates as security and design inconsistency.
Agents operationalize business users’ decisions rather than replacing them. The judgment still belongs to the business user, and their overrides are what keep a skill accurate — which makes removing them from the loop the wrong efficiency to chase.
What both trends quietly cost is control — Data and decision execution move to a third-party model; architecture erodes on the other. A harness is the moat: a policy layer and a fine-tuned model for agents, an ADLC for generated code.
Token spend scales with usage, not value, and never settles. Agent execution costs grow with every decision; generated code re-runs the same cycle through every fix and upgrade. That's a margin question worth answering before scaling past a pilot.