One reason I kept pushing on SWE-Agent economics in my dissertation is that the agentic era is easy to misunderstand. It is tempting to frame it as a UX improvement: faster coding, better assistants, cheaper automation.
That is real, but it is not the deepest change.
The deeper change is that intelligence is becoming an allocatable resource. Once agents can act with some autonomy, the problem becomes economic: how do we route scarce capability across tasks, budgets, quality thresholds, and time constraints?
That is exactly the kind of question I wanted to study in my dissertation on SWE-Agent Economics and SWEChain-SDK. I focused on it because software engineering is moving from static labor assumptions toward dynamic allocation problems.
Agentic systems make cost visible
In the old story, software work was mostly discussed in terms of teams, estimates, and ticket flow. In the agentic story, it becomes easier to measure the real tradeoffs:
- which agent finishes first,
- which one finishes cheapest,
- which one has the highest first-pass success,
- which one burns the most compute,
- which routing policy creates the best portfolio outcome.
That is why the economic lens matters. It turns a fuzzy conversation into one about mechanism design, resource allocation, and incentives.
The dissertation uses the language of SWE-Agent outsourcing markets because outsourcing markets make those choices explicit. The idea is not that every company will literally run an auction tomorrow. The idea is that auctions expose the structure of the problem in a way that centralized product flows usually hide.
Why I cared about Intelligence Per Watt
One clue that pushed me further into this area was the growing importance of efficiency metrics such as Intelligence Per Watt (IPW). Once model quality is no longer the only variable, system design has to care about capability per unit of energy, cost, and latency.
That is economically meaningful because it changes who gets selected. A slightly weaker agent with better cost-performance can win in a constrained environment. The agentic era is full of those tradeoffs.
In Go terms, that means the orchestration layer has to become explicit about utility:
package routing
type Candidate struct {
Name string
PriceCents int64
LatencyMS int
Score float64
}
func Utility(c Candidate) float64 {
// Trade off quality against both price and latency.
return c.Score - float64(c.PriceCents)/100.0 - float64(c.LatencyMS)/1000.0
}
This is not a production formula. It is a reminder that selection policy is an economic policy. Even a simple router is already making claims about what the system values.
Why I thought software engineering needed this framing
I focused on this in research because I did not want software engineering to adopt agents while leaving its evaluation language behind. If we keep treating agentic systems as isolated model demos, we miss the fact that they are participating in a larger allocation problem.
That is why the dissertation emphasizes controlled paired experiments. If you want to compare policies, you need a system where you can hold the environment steady and vary one rule at a time. Otherwise, people confuse noise with insight.
The economics is not optional
The agentic era creates an economic system whether we acknowledge it or not. Agents consume resources, compete for tasks, differ in comparative advantage, and operate under explicit or implicit incentives.
The practical question is whether we want to study those rules directly. My answer in the dissertation was yes. That is why I focused on building a framework where those interactions could be observed, logged, and rerun under comparable conditions.
To me, that is one of the most exciting parts of the whole field. It means software engineering is no longer only about writing code better. It is about designing systems where intelligence itself becomes a resource to allocate well.
Source
Game design and systems thinking share a common structure: a set of rules, agents acting within those rules, and emergent behavior that no individual agent intended. The same structure appears in market design, protocol design, and software architecture. The engineer who studies games learns to see the rules behind the behavior. The behavior that looks like chaos is often the equilibrium of a system whose rules you haven't discovered yet. The discovery is the engineering.
The agentic era is not about agents doing what humans did. It is about agents doing what humans could not. The economics change when the cost of a task drops from an hour of labor to a penny of compute. The change is not incremental. It is structural.