A look at Zhenfeng Cao’s research paper “Agentic Software: How AI Agents Are Restructuring the Software Paradigm”

Introduction

In the last few years, AI has steadily stopped being just a tool that helps a programmer write code. AI agents can already analyze software projects, plan changes, use tools, run commands, test solutions and fix the bugs they find.

That raises a more fundamental question: is the model of software development itself changing?

In the research paper Agentic Software: How AI Agents Are Restructuring the Software Paradigm, author Zhenfeng Cao examines a possible shift from traditional Software Engineering to a new discipline — Agentic Engineering.

The paper’s main claim isn’t that programming is dying. The author offers a different lens: the center of engineering work is gradually moving from writing source code to designing, managing and overseeing autonomous agentic systems.

That’s a meaningful distinction. This isn’t just about speeding up development with AI — it’s about a possible change in how software gets built, who does the engineering work, and what the human is responsible for.

1. Three generations of software

The author frames the evolution of software as three successive generations.

Software 1.0 — local software

In the traditional model, the developer describes the system’s logic up front, codes the rules of behavior, and defines how data is processed.

The user installs the program and interacts with its pre-built capabilities. Development, infrastructure and support largely sit with the creators or owner of the software product.

The core deliverable of this model is source code and the system built from it.

Software 2.0 — Software as a Service (SaaS)

The next stage is the shift to cloud-based software products.

Infrastructure, operations and updates move to the vendor. The user accesses a ready-made service over the internet and works with its functionality without managing the underlying implementation.

Software becomes a service, available by subscription or through a cloud platform.

Software 3.0 — Agent as a Service (AaaS)

The third stage the author examines is tied to the rise of autonomous AI agents.

The user states the task and the desired outcome. The agent plans its own execution, picks tools, takes actions, writes code where needed, and checks the result it produced.

In this model, the user interacts less with pre-built functionality and more with a system that can carry out the tasks it’s given.

In other words, the object of development itself changes: instead of a program with fixed logic, you get an agentic system that can dynamically organize how work gets done.

2. From Software Engineering to Agentic Engineering

One of the paper’s central claims is a shift in the human’s role in the development process.

In traditional Software Engineering, the human directly drives most engineering operations: analyzing requirements, designing the architecture, writing the code, testing it and fixing bugs.

In Agentic Engineering, a significant share of those operations can be handed off to specialized agents.

Traditional Software EngineeringAgentic Engineering
Source code is the core deliverableThe agentic system is the core object of design
The human drives executionAI agents execute and coordinate operations
Logic is mostly defined up frontPart of the logic forms at runtime
Development is organized around sequential engineering operationsWork is built around autonomous, iterative cycles
The human writes and edits the code directlyThe human states intent and oversees the implementation
The result is a working programThe result is a completed task
Developers do the refactoringAgents can take part in analyzing and changing their own system

This doesn’t mean all these contrasts are already reality. The table captures the conceptual opposition between the two models that the author proposes.

Importantly, Agentic Engineering doesn’t remove the need for engineering knowledge — it changes how that knowledge gets applied.

A developer still needs to understand how the system works, but increasingly the job isn’t implementing every feature by hand — it’s organizing the agents’ work correctly and checking the result.

3. The human’s new role: four key competencies

In section 4.3, the author identifies four areas that become especially important for a human working with autonomous agents.

3.1. Intent Articulation

A human needs to be able to precisely describe goals, requirements, constraints and expected outcomes.

It’s not enough to just ask an agent to build an app or fix a bug. You need to define:

How well the task is specified becomes one of the key factors in whether the agents’ work succeeds.

3.2. Architectural Oversight

The human is responsible for the system’s architectural integrity and how its components interact.

This covers:

The more autonomy agents get, the more it matters that there’s a shared architecture and clear rules of engagement.

3.3. Quality Calibration

An agent can report that it completed a task successfully, but that’s not proof the result actually meets the requirements.

So you need to design a verification system:

The human defines what counts as a quality result, and builds the mechanisms that can verify it.

3.4. Ethical Governance

Autonomous agents need to operate within set rules.

Their actions need to be checked against business, legal and ethical requirements, with clearly defined permissions and limits.

This matters most when working with personal data, financial transactions, critical infrastructure and other sensitive processes.

As a result, the developer’s role gradually widens: they become an architect, coordinator and auditor of agentic systems.

4. The core problem: today’s agents aren’t reliable yet over the long haul

One of the paper’s most important sections covers the limits of today’s AI agents.

In section 5.2, the author looks at results from the EvoClaw study, which examines agents’ ability to maintain and evolve software projects over extended periods.

The paper reports the following figures:

Task typeSuccess rate
Isolated tasksOver 80%
Continuous project evolutionNo more than 38%

The author points to a substantial drop in success — more than 54 percentage points.

The experiment description mentions 12 leading models and 4 agent frameworks.

These results matter beyond the numbers themselves — they show a fundamental gap between completing a single task and sustaining long-term work on a complex software system.

The author identifies four core problems.

4.1. Context Drift

As a project grows, it gets harder for an agent to hold onto an understanding of the whole architecture.

It can successfully solve a local task while failing to account for earlier decisions, component relationships, or constraints elsewhere in the system.

4.2. Error Propagation

Mistakes made at one stage can carry forward into later changes.

If later agents treat a flawed result as reliable, the problem compounds and spreads across more and more components.

4.3. Technical Debt Awareness

Agents can propose solutions that work for the current scenario but create problems for the system’s future development.

For example, a local fix might violate architectural principles, increase coupling between components, or make future refactoring harder.

4.4. Verification Fidelity

Even tests that pass don’t always prove the system is correct.

Testing can miss hidden semantic bugs, business-logic violations, and problems in how components interact.

So the author’s point stands: fully autonomous development can’t yet be considered reliable across all production scenarios.

This is one of the paper’s most important conclusions. Being able to generate code and complete individual tasks doesn’t yet mean being able to independently sustain a complex software product.

5. Four stages of Agentic Engineering’s evolution

To describe where this is heading, the author proposes a four-stage forecast model.

StagePeriodCore capabilities
I. Tool-Augmented2023–2025AI assistants, code generation, bug fixes
II. Single-Task Autonomous2025–2027Independently completing individual tasks
III. Multi-Agent Teams2026–2029Teams of specialized AI agents
IV. Self-Evolving Ecosystems2028+Self-developing, adaptive agentic ecosystems

This is specifically the author’s own forecast model, not a confirmed industry-wide roadmap.

Stage three — Multi-Agent Teams — is especially interesting.

The author describes an architecture where different agents carry out specialized functions:

Instead of one general-purpose AI assistant, you get a team of specialized executors working within a shared process.

The human still keeps responsibility for the goals, the architecture and the quality of the whole system.

Stage four envisions self-developing ecosystems capable of improving their own tools, processes and working strategies.

But reaching that stage fully still leaves plenty of unsolved problems: safety, change control, reproducibility, evaluation quality, and preventing errors from compounding.

6. What the author recommends doing now

Section 7.1 of the paper lays out practical recommendations for moving toward the new development model.

1. Shift from producing code to designing tasks for agents.

Build up Intent Engineering skills: frame tasks so an agent can independently plan and execute the work within the given constraints.

2. Learn agent orchestration.

Learn to split work across specialized executors, manage context handoff, and handle dependencies and shared memory.

3. Invest in observability.

Build infrastructure for tracing agent actions, analyzing failures, catching bad results, and measuring execution quality.

4. Use human-in-the-loop.

The author proposes a principle:

Human-in-the-loop, Agent-in-the-driver’s-seat.

The agent does the bulk of the work; the human owns the goals, the critical decisions, and checking the outcome.

For businesses, the recommendation is also to start with processes that have clear success criteria and can be checked automatically.

That lets you expand agent autonomy gradually, instead of handing them control of mission-critical processes right away.

7. How well-founded are the paper’s conclusions

It’s worth being precise about this paper’s status.

It’s a research publication on arXiv, not a settled scientific consensus.

Several kinds of claims need to be kept separate:

The EvoClaw results reported are interesting, but on their own they don’t prove every conclusion the author draws about the future of development.

Some of the claims need further scrutiny.

In particular, the idea that growing compute and model capability gradually removes the limits of human cognition remains a hypothesis. AI agents have their own constraints: context window, memory, sequencing of actions, compute cost, tool reliability, and the quality of the feedback they get.

On top of that, framing it as humans versus model compute overlooks that engineering work isn’t just information processing — it also carries responsibility for the consequences of decisions.

So the paper is best read as a description of a promising direction and a set of hypotheses about where the industry is headed, not as proof that the programming profession is about to disappear.

8. What this means for developers and technical leaders

The main practical takeaway can be put like this:

A developer’s value is gradually shifting from being able to produce code themselves to being able to build, manage and oversee the systems that produce a working software result.

Programming knowledge doesn’t go away in this shift — it becomes the tool you use to keep agents in check.

For example, if an AI agent built an authorization system, a technical lead still needs to be able to judge:

Without that technical competence, a person risks becoming an operator who takes AI’s output on faith.

So the strongest position isn’t rejecting engineering knowledge — it’s moving up a level in how you apply it: architecture, systems thinking, agent management, quality control, and owning the result.

9. VOLY and the infrastructure for Agentic Engineering

It’s worth looking at these ideas in the context of the VOLY project.

VOLY is being built as a Control Plane for AI Coding Agents — an infrastructure platform that brings together agent orchestration, model and provider access, task execution management, project memory, result verification and cost control.

That direction maps directly onto the problems the paper describes.

If Agentic Engineering means moving from individual AI assistants to autonomous engineering systems, those systems need a control layer.

It has to handle not just launching agents, but coordinating their work, preserving context, controlling execution, and verifying results.

Five areas stand out as especially important.

9.1. Agent Orchestration

Managing specialized agents, distributing tasks, and coordinating how they work together.

This is what lets you move from one general-purpose executor to teams of agents with different roles and responsibilities.

9.2. Persistent Memory

Preserving context, architectural decisions, change history and project knowledge across separate sessions.

This is one way to fight Context Drift and the loss of information over long-running work.

9.3. Execution & State Management

Managing task execution, dependencies, state and process lifecycle.

For autonomous development, it’s not enough to just launch an agent — you need to know what stage a task is at, what’s already been done, and whether it’s safe to resume after a failure.

9.4. Observability & Evaluation

Tracing actions, collecting results, testing, evaluating quality, and auditing changes.

This is the infrastructure foundation for addressing Verification Fidelity.

9.5. Cost & Model Routing

Managing cost, model selection and backup executors.

As the number of agents grows, development cost becomes a factor you need to manage at the level of the whole system, not just each individual request.

In that context, VOLY isn’t just a wrapper around Claude Code, Codex or other tools.

It’s an attempt to build an independent infrastructure where different AI executors can work within one managed process.

That kind of control layer becomes especially important as the shift toward Multi-Agent Engineering continues.

Conclusion

Zhenfeng Cao’s paper is interesting not because it claims programming is ending.

Its real value is in describing a possible shift to a new engineering discipline, where the human spends less time producing every line of code directly and more time designing, coordinating and overseeing autonomous systems.

That shift won’t happen overnight. Today’s agents still struggle significantly with long-running work on complex projects, which is why architecture, testing, observability and human oversight remain critical.

But the direction already deserves attention.

For developers, that means building competencies in systems architecture, orchestration, quality management and process design.

For business, it’s a chance to rethink the approach to automation, and gradually hand AI agents not individual operations but whole sequences of engineering and operational work.

For builders of infrastructure platforms, it points to a new class of products built around managing autonomous agents.

Agentic Engineering isn’t the end of programming. It’s a shift from writing software code to designing and managing systems that can carry out engineering work on their own.


Source

Agentic Software: How AI Agents Are Restructuring the Software Paradigm

Author: Zhenfeng Cao
Venue: arXiv
Published: June 2026
Length: 15 pages

Note: this summary and interpretation is not a substitute for reading the original paper. The forecasts and assessments described belong to the paper’s author.