Skip to main content

Agentic Engineering’s Missing Equation: Pricing the Unpredictable

Construx principal consultant Steve Tockey makes a profound observation: “If you are not basing your software technical decisions, at least in part, on engineering economy, then you are not—by definition—doing software engineering.” He points to a quote by Leon Levy: “...software economics has often been misconceived as the means of estimating the cost of programming projects. But economics is primarily a science of choice, and software economics should provide methods and models for analyzing the choices that software projects must make.” This got me thinking about the current state of agentic engineering. We are essentially lacking the engineering economy required to make sound investment choices. To highlight this gap, this blog compares traditional cash-flow streams before adding a modern perspective. FinOps—including tokenomics—is a vast field, and this discussion only scratches the surface. Its aim is to highlight a growing trend: companies replacing human software engineers with agentic solutions based solely on short-term cost calculations.

The Baseline: Classical Cash-Flow Stream

In the freely available Construx Lunch & Learn session Software Engineering 101, Steve Tockey models how a for-profit company makes engineering decisions. To choose on economic grounds, the hypothetical company compares the cash-flow streams of several mutually exclusive proposals, including the development of a new payroll system.

The Classical Assumptions:

  • Initial Investment: $250k
  • Staffing Costs: $225k/FTE per year.
  • Development: 9 developers in Years 1 and 2.
  • Maintenance: 3 maintainers in Years 3 through 7.
  • Income: Sales, upgrades, maintenance contracts, and training classes begin in Year 1.

Using a minimum acceptable rate of return (MARR) of 12%, Tockey calculates the present worth (PW) of the entire cash-flow stream. By discounting future cash flows back to today, the company can determine if development of a payroll system is a better investment than a some alternative (like "doing nothing" or restructuring another package). The resulting PW is $874k—a clear, economically driven justification for the project compared to other choices. Again, consult the previously mentioned session for more details.

The Twist: Agentic Cash-Flow Stream

Now, let’s imagine a modern alternative. The company decides to leverage agentic engineering. Instead of a team of 9 developers, they hire just one developer to orchestrate a fleet of autonomous AI agents. Because agents can generate code at breakneck speed, the project is delivered in a single year; actually much less, but let keep things simple. Instead of 3 human maintainers, they retain just one human maintainer to review and guide the agents during the maintenance phase.

The New Assumptions:

  • Initial Investment: Let's assume $50k (the agentic platform subscription and infrastructure).
  • Staffing Costs: 1 developer in Year 1; 1 maintainer in Years 2–7.
  • Income: Matches the classical model exactly.

If we look at this through the lens of cost accounting, the choice is a no-brainer. You are saving millions in human payroll, accelerating time-to-market by a year, and drastically reducing overhead. The immediate "best practice" is obvious: adopt the agents.

Why the Cash-Flow Stream Breaks Down

In classical engineering economics, we can discount future cash flows because we understand the variables: human salaries are predictable, licensing costs are known, and maintenance effort is a historically grounded estimate. 

In agentic engineering, the core variables are structurally indeterminate. We cannot map a cash-flow stream because of the various missing data.

1. The Unknown Token Liability

Where do tokens fit in our example cash-flow categories? They are an operating and maintenance cost. But how much will the single maintainer spend on tokens in Year 3 to fix a bug? An agent working on a large codebase must re-read vast amounts of context. Because agentic loops can be unpredictable—sometimes spinning endlessly on a single task—the future token consumption is a long-tailed distribution. We cannot convert present token values into future token values because we don't know the volume.

2. The Volatility of the Unit Price

Even if we could predict the volume of tokens, we cannot predict the price. Are we currently experiencing a temporary price war, or a permanent deflation in inference costs? More dangerously, what happens when the economic regime shifts? 

We already saw this with GitHub Copilot. Users built workflows assuming a flat-rate economic model. Then, Copilot shifted to a usage-based billing model, and some users saw bills jump 10x overnight. If a vendor can re-price the fundamental building block of your agentic workflow with little warning, you cannot accurately discount future cash flows. The risk premium is unquantifiable. 

3. The Maintenance Enigma

In classical engineering, maintenance is a known cost. In agentic engineering, maintenance creates a "verification debt." If an agent writes 10,000 lines of code in a week, how much human time will it take to verify it? Will the human maintainer need to use even more tokens to have an agent explain its own code? We are trading human salary costs for an unknown future liability of AI compute costs and human review time. 

4. Commercial vs. Open-Source Shifts

If the company plans to use an open-source model to control costs, what happens when that model's maintainers pivot to a commercial model, or when the licensing terms change? The future state of the software supply chain is opaque. 

The Cost-Accounting Fallacy

Because we cannot produce a defensible, discounted cash-flow stream for agentic variant, engineering teams are defaulting to  cost-accounting choices. They look at the ledger today and say: “A token costs $0.001, a human costs $0.01. Therefore, we choose the token.” This is not engineering. As E. Paul DeGarmo et. al. notes, “...engineering is about finding the balance between what is technically feasible and what is economically acceptable.” Or citing Arthur Wellington, it is “...the art of doing that well with one dollar which any bungler can do with two...”

Right now, agentic engineering is entirely focused on how to spend that one dollar today, while ignoring the fact that the dollar is a variable-rate, unhedged liability that might cost ten dollars in Year 3. 

Conclusion

We need a new framework for agentic engineering economics, a way to model:

  • Regime-Shift Risk: How much architectural flexibility are we willing to pay for today to protect ourselves from future vendor price hikes?
  • Context Decay: How much will it cost to re-feed an agent the context of a sprawling codebase in Year 4?
  • Compute-Liability Discounting: How do we allocate the financial risk of infinite agent loops?

Until we can draw a cash-flow diagram for an agentic system and calculate a present worth against a classical alternative, we aren't doing real software engineering. The volatility of vendor-controlled token pricing and the unquantifiable nature of endless agentic loops pushes AI development beyond traditional risk models into pure speculation.

Comments

Popular posts from this blog

Reverse AI Pair Programming: Saving the Next Generation of Engineers

We are currently engineering our own succession crisis. By handing junior developers AI coding assistants that default to generating architecture and logic at superhuman speeds, we have solved the velocity problem—but we are quietly eroding foundational engineering muscle memory. We are raising a generation of developers who can prompt an app into existence but will be completely paralyzed when the underlying systems collapse. If you look around the industry, the proposed solution is usually a tool: a "Socratic prompt" or a custom GPT designed to ask questions rather than write code. But tools are not enough. In a sprint-driven culture that incentivizes shipping features by Friday, individual discipline will always lose to the temptation of generative autocomplete. When an AI acts as the "Driver" at the keyboard, regular AI pair programming , the human is elevated to the role of "Navigator." This works beautifully for senior engineers who already possess t...

The Power of a Command-Line Processor

A command-line processor, as its name implies, is a software appliance intended to be executed from a command-line in pipelined fashion. Most operating systems are equipped with bunch of utilities that can be ingeniously combined to create powerful mini programs for transforming data. We will focus our attention here on jq specialized to mangle JSON data similarly how sed crunches textual content. You can easily start using it by issuing brew install jq on macOS (or download it for other operating systems). Nonetheless, even without placing anything on your machine, there is also a nice playground for trying out things online. The following example illustrates what sort of actions could be crafted into a unified instruction, i.e., mini program that may be reused as a whole: > echo "A test string." | jq -R "ascii_upcase | gsub(\"STRING\"; \"CONTENT\")" "A TEST CONTENT." The input is piped into jq as an ordinary string (this is hi...

Explaining High Level Concepts via Low Level Constructs

In education teachers strive to demystify tough concepts by coming up with succinct and minimalistic examples and case studies. Frequently, despite investing great effort, the underlying mechanisms remain surrounded by mystic clouds just because the substrate over which things are exposed is at an overly high abstraction level. This is the case with recursion when illustrated via mainstream programming languages. In this blog, I would like to share a different approach of explaining processes under the hood using a low conceptual programming layer, namely machine language. It is remarkable how students easily comprehend recursion at this level without being dragged into thinking what is really going on in the background in programs written in Java, C#, Python, or any other modern programming language. Problem Description For teachers the booksite accompanying the book Computer Science: An Interdisciplinary Approach by Robert Sedgewick and Kevin Wayne is an excellent source of educati...