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. As agentic AI platforms mature, this model is moving beyond individual workflow automation toward broader agentic AI applications.
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.
This distinction is particularly important when designing agentic AI applications for enterprise environments, where autonomous reasoning still has to operate within deterministic systems of record.
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 — an agentic AI architecture designed to govern how the agent perceives, reasons, and acts:
- 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 practice, these components form the foundation of many agentic AI frameworks and platforms, but the architecture around the model is what determines how much control an organization retains.
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.
This is why AI governance is not an optional layer around agentic AI architecture. It is part of the architecture.
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.
This is an important consideration when evaluating agentic AI solutions. The question is not only whether an agent can perform a task, but what every execution costs and how that cost changes at production scale.
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 AI 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.
This is also where agentic AI development differs from simply using generative AI for code completion: the coding agent can reason across a task and execute multiple development actions rather than simply generate a code snippet.
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 becoming a core consideration for agentic AI solutions, because the value of an agent depends not only on what the underlying model can generate, but on how reliably the organization can constrain, validate, and govern its behavior.
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. These elements form the foundation of modern agentic AI architecture, frameworks, and platforms.
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.
As agentic AI development moves from experimentation to production, organizations will increasingly evaluate agentic AI platforms, frameworks, and solutions not only by how much autonomy they provide, but by how effectively they preserve control, determinism, security, and ownership.
This blog is originally published on substack.
Frequently Asked Questions About Agentic AI and Agentic Software
What is agentic AI and how does it function?
Agentic AI refers to AI systems that can interpret a goal, understand context, make decisions, use tools, and take actions with a degree of autonomy. Unlike a conventional software system that follows predefined logic, an agent can determine what to do based on the situation it encounters.
An agentic AI system typically combines a model with context, skills, tools, memory, and a harness that controls how the agent operates.
What is agentic AI and how does it differ from other AI types?
Traditional AI systems typically execute predefined rules or perform specific predictive tasks. Generative AI creates new content based on learned patterns. Agentic AI adds another layer: the ability to interpret goals, reason about actions, use tools, and execute tasks with varying levels of autonomy.
This makes agentic AI a distinct computational paradigm rather than simply another form of content generation.
What are the best agentic AI tools for software development?
The best agentic AI tool depends on the development team's technology stack, workflow, security requirements, and level of autonomy required. Agentic AI coding tools can assist with code generation, debugging, testing, refactoring, and repository-level tasks.
For enterprise development, organizations should evaluate these tools on more than coding speed. Architecture consistency, security, governance, maintainability, code ownership, context control, and validation are equally important.
What is the best coding tool for agentic AI development?
There is no single best coding tool for every development team. The right tool depends on the team's programming languages, frameworks, repository structure, security requirements, deployment environment, and governance model.
For enterprise agentic AI development, important evaluation criteria include architectural consistency, code ownership, testing, security, context grounding, reproducibility, maintainability, and governance — not just code generation speed.
What is an agentic AI coding tool and how does it work?
An agentic AI coding tool applies agent-based reasoning to software development. It can interpret a requirement, inspect relevant code and documentation, determine implementation steps, generate or modify code, use development tools, run tests, and iterate based on the results.
The reliability of an agentic coding tool depends not only on the underlying AI model but also on the context, tools, guardrails, and validation mechanisms surrounding it.
What features can I expect from an agentic coding assistant?
An agentic coding assistant can provide capabilities such as:
- Code generation and modification
- Repository and codebase understanding
- Debugging
- Test generation and execution
- Refactoring
- Documentation generation
- Tool and API use
- Multi-step task execution
- Context retrieval
- Automated validation
Enterprise environments may also require architecture controls, security guardrails, governance, auditability, and human review.
What exactly is agentic code?
Agentic code generally refers to software created, modified, or operated through agentic systems. In software development, it can describe code generated or changed by autonomous coding agents.
The important distinction is that the generated code itself remains conventional executable software. The agentic behavior comes from the system that reasons about what code needs to be created or changed and how the task should be completed.
What are the key features of agentic software?
Key features of agentic software include goal-oriented behavior, contextual reasoning, tool use, multi-step execution, memory, planning, feedback loops, and autonomous or semi-autonomous action.
The level of autonomy depends on the architecture, tools, permissions, guardrails, and human oversight surrounding the agent.
What are the key concepts in agentic software engineering?
Key concepts in agentic software engineering include agentic AI architecture, context, skills, tools, memory, orchestration, evaluation, guardrails, observability, governance, and human-in-the-loop validation.
For enterprise software, architecture and validation are particularly important because probabilistic AI behavior must ultimately produce software and decisions that organizations can control and trust.
What is the relationship between software factories and the agentic moment?
Software factories industrialize software production through standardized processes, reusable components, automation, and engineering systems.
The agentic moment extends this model by introducing autonomous AI systems into software production. Agents can increasingly participate in requirements, coding, testing, documentation, and other development activities.
This makes architecture, validation, governance, and reproducibility increasingly important because the software factory now has probabilistic actors participating in the production process.
