Modern Software Plane: Platform and Intelligence

Software competes on two planes: the platform, everything a human touches, and the intelligence, everything the software can understand and do. As agents replace humans as the operators of software, the platform moat thins, interfaces converge back to the command line, and the moat moves to intelligence and to the interface agents use.

Issue
19/ 19
Reading
16min
Figures
4
Equations
4

Eryawan Presma Yulianrifat

  • software-engineering
  • economics
  • notes

For most of software’s history, the argument about how to build it was an argument about structure: which pattern, which layers, which separation of concerns. Then the argument moved to the screen: which product looked better, felt faster, and was easier to learn. Both arguments assumed the same thing, that a person writes the software and a person operates it. AI is removing the first assumption now and the second one next. This post is about what software competes on once neither holds.

Committed 2026-11-11: software competes on two planes, Platform and Intelligence. As agents replace humans as the operators of software, the platform moat built for human hands thins, interfaces converge back to the command line, and the moat moves to the intelligence plane and to the interface agents use.


Principles

Six lines that summarize the argument.

  1. Patterns serve whoever writes the code. When that is increasingly a model, the choice of pattern stops being a moat.
  2. Software competes on two planes. The platform is everything a human touches; the intelligence is everything the software can understand and do.
  3. An interface is priced in its operator’s learning cost. The GUI won because humans learn slowly.
  4. When the operator changes, the interface follows. Agents learn from documentation almost for free, and they operate fastest through text.
  5. The platform moat does not vanish; it changes audience. It moves from the human-computer interface to the agent-computer interface.
  6. Seats become calls. Pricing per human seat assumes a human operator.

The Old Map: Software as Patterns

The popular view of software engineering was a catalogue of architecture patterns. Model-View-Controller came first: Trygve Reenskaug described it at Xerox PARC in 1979, for Smalltalk, to separate the data a program holds (the model) from how it is shown (the view) and from how a user’s input changes it (the controller). Its descendants filled the next four decades. Model-View-Presenter and Model-View-ViewModel moved the logic around for different UI toolkits. Flux and Redux made data flow one way through web front ends. On the server, REST gave resources uniform verbs, microservices split one deployable into many, and clean and hexagonal architecture put the business rules in the middle and pushed every framework and database to the edge.

Read as a list, these look like discoveries about software. Read as a history, they are answers to the limits of the people writing it. David Parnas argued in 1972 that a system should be split into modules so that each hides a design decision that is likely to change, so a programmer can change one module without understanding the others. That is a statement about human memory and attention. Melvin Conway observed in 1968 that a system’s structure copies the communication structure of the organization that built it. That is a statement about how people coordinate. Fred Brooks showed in 1975 that adding people to a late software project makes it later, because the cost of communication grows faster than the work each new person adds.

Citation: D. L. Parnas, “On the Criteria To Be Used in Decomposing Systems into Modules,” Communications of the ACM 15(12), 1053–1058, 1972 · M. E. Conway, “How Do Committees Invent?,” Datamation 14(4), 28–31, 1968 · F. P. Brooks, The Mythical Man-Month, Addison-Wesley, 1975.

Every pattern on the list is a way to make a large program fit into the heads of the people maintaining it. That is why teams argued about them, and why getting the architecture right was something a strong engineering organization could do better than a weak one.

AI changes who writes the code. A model can implement MVC, MVVM, a hexagonal core or a set of microservices on request, and it can move a codebase from one to another faster than a team could agree to. The pattern still matters for the code: a modular codebase is easier for an agent too, because a well-hidden module is one the agent does not need to read to change its neighbour, and context is still a cost. But when any competent pattern can be produced on demand, the choice of pattern is no longer something one company does better than another. It stops being a moat.

The question becomes what is.


Two Planes

Networking has a useful vocabulary for this. A router has a control plane, which decides where traffic should go, and a data plane, which moves the packets. The two are designed, scaled and competed on separately. Software products have the same split, and naming it makes the rest of the argument precise.

The platform plane is everything that sits between the software and the person using it: the interface and how it feels, the features and how they fit together, onboarding, integrations with other tools, and the reliability that keeps it all up. Site reliability belongs here. It is invisible when it works and is the only thing anyone notices when it does not.

The intelligence plane is what the software can understand and do: its capability on the task, the inputs it accepts (text, images, audio, documents, a whole codebase), its speed, its cost per task, its accuracy, and how long it can work on its own before it needs a person.

The two planes of a software product Intelligence plane capability · supported inputs · speed cost per task · accuracy · autonomy Platform, human-facing UI and UX · look and feel features · reliability Platform, agent-facing CLI · API · documentation permissions · reliability a human an agent today most traffic enters on the left; the argument is that it moves right
A product competes on two planes. The platform has two faces, one for human operators and one for agents, and reliability matters on both. Today almost all use comes through the human-facing side.

Where the Moat Lives Today

Today every serious product competes on both planes at once. Buyers compare products on the old platform questions (is it pleasant, is it reliable, does it fit with the tools we already use) and, increasingly, on intelligence questions: what can it do on its own, which inputs does it accept, how fast is it, and how often is it wrong. Most product teams are now also AI teams, and most roadmaps have an intelligence line beside the feature line.

Both planes are moats today because both are hard to copy. A polished interface that a team has learned is a switching cost. An integration with forty other tools is years of work. A system that handles a messy input reliably is hard to reproduce. The argument of this post is that one of these moats is about to get much thinner, and it is the one built for human hands.


Who Operates the Software

The human-facing platform exists because a human is the operator. Every pixel of it is there to make a person’s next action easy to find, easy to take and hard to get wrong. That is valuable exactly as long as a person is the one acting.

The operator is changing. A growing share of software use is an agent acting on someone’s behalf: a coding agent running a test suite, a support agent querying an order system, an assistant filing an expense or booking travel. The likely end point is a personal agent per person, which holds that person’s context and preferences and operates the rest of their software for them.

The division of work that follows is clean. The agent handles interaction with platforms. The human handles interaction with humans. People still decide what they want, judge whether they got it, negotiate, persuade and take responsibility. They do less clicking through screens to get there.

This is the same split as the two-department enterprise: building gets automated, while selling, the work of earning another person’s trust, stays human. Here it applies to every individual’s software rather than to a company’s org chart.

A useful way to state the consequence is to weight a product’s value by who operates it. Let hh be the share of a product’s use that comes from human operators, PhumanP_{human} and PagentP_{agent} the quality of its human-facing and agent-facing platform, and II its intelligence. As a sketch,

V=h⋅Phuman+(1−h)⋅Pagent+IV = h \cdot P_{human} + (1 - h) \cdot P_{agent} + I

Today hh is close to 1, so PhumanP_{human} carries the whole platform term, and that is where companies invested. As hh falls, the same investment buys less, and the agent-facing platform, which most products barely have, starts to carry the weight. The intelligence term does not depend on hh at all: a capable product is worth the same to an agent as to a person.


Why Interfaces Converge on the CLI

If agents become the operators, what interface do they want? The answer is the oldest one: text commands.

A Short History of the Operator

The first interactive computers were operated through text. Unix, built at Bell Labs from 1969, came with a philosophy for its command-line programs that Doug McIlroy stated and Peter Salus later condensed into three lines: write programs that do one thing and do it well; write programs to work together; write programs to handle text streams, because that is a universal interface.

Citation: M. D. McIlroy, E. N. Pinson, B. A. Tague, “UNIX Time-Sharing System: Foreword,” The Bell System Technical Journal 57(6), 1899–1904, 1978 · P. H. Salus, A Quarter Century of UNIX, Addison-Wesley, 1994.

The graphical interface replaced it for most people, from the Xerox Alto in 1973 to the Macintosh in 1984, then the web and then the phone. It did not win because it was faster for an expert. It won because it was cheaper to learn: a menu shows you what is possible, where a prompt shows you nothing. Experts kept the command line throughout, because once the commands are learned, typing one is faster than finding it.

Who operates the software, and through what text graphics, for people text again 1969 Unix 1973 Xerox Alto 1984 Macintosh 1991 the web 2007 iPhone 2020s agents, tool calls operator: a human an agent
The interface followed the operator. Graphics took over when software reached people who could not be expected to learn commands. When the operator becomes an agent, the reason for graphics goes with it.

The Cost of Operating an Interface

The trade-off can be written down. Using an interface has a one-time learning cost LL and a cost per operation cc, so NN operations cost

C(N)=L+c⋅NC(N) = L + c \cdot N

A GUI has a low LL and a high cc: easy to start, slow to repeat, because every operation means finding the control, moving to it and clicking. A CLI has a high LL and a low cc: hard to start, fast to repeat, and easy to compose with other commands and scripts. The CLI is cheaper once the number of operations passes the break-even

N∗=Lcli−Lguicgui−ccliN^{*} = \frac{L_{cli} - L_{gui}}{c_{gui} - c_{cli}}

For a human, Lcli−LguiL_{cli} - L_{gui} is weeks of learning, so N∗N^{*} is large, and most people never reach it with most software. That is the economic case for the GUI, and it was correct.

For an agent, every term moves the other way. The CLI’s learning cost is reading the documentation and the --help output, which takes seconds. The GUI’s learning cost is not lower for an agent and is often higher, because it has to infer from screenshots what a person would see at a glance. And the GUI’s cost per operation is far higher: each click means capturing the screen, finding the target, acting and checking the result, where a command is one line of text. With Lcli≤LguiL_{cli} \leq L_{gui} and ccli<cguic_{cli} < c_{gui}, N∗N^{*} is zero or negative. The command line is cheaper from the first operation.

Total cost of N operations, by interface and operator schematic, not to scale number of operations, N total cost C(N) N* for a human GUI CLI, operated by a human CLI, operated by an agent learning cost L for an agent the CLI line starts lower and rises slower: no break-even to reach
C(N) = L + c·N. For a person, the command line pays off only after a break-even number of operations most people never reach. For an agent, it is cheaper from the first one.

What “CLI” Means Here

The claim is not that everything ships as a terminal program. It is that every serious platform converges on the CLI’s principles, which McIlroy’s three lines already state: small operations that each do one thing, that compose, and that speak text. A command-line tool, a well-designed API, and the tool definitions an agent is given through function calling or the Model Context Protocol are the same idea in different clothes. Several of the most prominent coding agents already run in a terminal.


From HCI to ACI: The Platform Moat Changes Audience

If the human-facing platform thins, does the platform plane stop mattering? The best evidence says no. It changes audience.

In 2024, Yang and colleagues built SWE-agent, a system that lets a language model fix real GitHub issues, and asked how much the interface the model works through affects its success. They called it the agent-computer interface, ACI, by analogy with human-computer interaction. The baseline gave the model a plain Linux shell. SWE-agent gave it a small set of commands designed for a model: a file viewer that shows a bounded window of lines with line numbers, a search that returns a concise summary instead of every match, and an editor that runs a linter and rejects an edit that would break the syntax. With the same model, GPT-4 Turbo, on the same 300 SWE-bench Lite tasks, the shell-only agent resolved 11.00% and SWE-agent resolved 18.00%, a 64% relative increase.

Citation: J. Yang, C. E. Jimenez, A. Wettig, K. Lieret, S. Yao, K. Narasimhan, O. Press, “SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering,” NeurIPS 2024, arXiv:2405.15793.

Two things in that result matter for this argument. First, both arms are command-line interfaces. The improvement did not come from adding graphics; it came from designing the text interface for its operator. Second, the gain came from the interface alone, with the model held fixed. The platform plane still moves the outcome. It is just a different platform.

So the platform moat migrates. The questions that used to be about the human-facing side (is it discoverable, does it guide the user, does it prevent mistakes) get asked again of the agent-facing side:

Reliability matters more, not less. An agent calls far more often than a person clicks, retries automatically, and has no patience for an outage, so every weakness in uptime and latency is multiplied by the agent’s call rate.

The human-facing interface does not disappear either. It shrinks to the moments where a person must be present: setting goals, reviewing what the agent proposes, approving what cannot be undone, and building the trust that lets them delegate more next time. The GUI becomes a review surface rather than a work surface.


The Intelligence Plane Is Still Climbing

The other half of the thesis is that the intelligence plane is where the moat moves, and that it is still rising fast. Two measurements support that, and they measure different things.

The first is research activity. The main track of NeurIPS, one of the largest machine learning conferences, received 9,122 paper submissions in 2021 and 21,575 in 2025, about 2.4 times as many in four years.

NeurIPS main-track paper submissions official counts 9,122 9,634 12,343 15,671 21,575 2021 2022 2023 2024 2025 Bar heights proportional to the counts. Source: NeurIPS fact sheets (2022–2024) and program chairs (2025).
Submissions to the NeurIPS main track more than doubled between 2021 and 2025. This counts research activity, not capability.

Citation: NeurIPS 2022 Fact Sheet (2021 and 2022 counts), NeurIPS 2023 and 2024 Fact Sheets, media.neurips.cc · “Reflections on the 2025 Review Process from the Program Committee Chairs,” NeurIPS blog, Sep 2025.

Paper counts measure how many people are working on the problem, not how much progress they make; a field can publish more while advancing less. So the second measurement is of capability directly. METR measures the length of task, in the time it takes a human expert, that a model completes with 50% reliability. Across frontier models from 2019 to early 2025 that length doubled roughly every seven months, and the best model it measured then completed tasks that take a human about 50 minutes. If H0H_0 is the horizon today and tt is in months, the trend reads

H(t)=H0⋅2 t/7H(t) = H_0 \cdot 2^{\,t/7}

This is a fitted trend, not a law. METR itself notes that the estimate depends on which tasks are measured and that extrapolating it carries real uncertainty. But read alongside the research activity, it says the same thing: the intelligence plane has not plateaued, and every gain in it widens the gap between what an agent can do through a good interface and what a person would bother to do through a GUI.

Citation: T. Kwa et al. (METR), “Measuring AI Ability to Complete Long Tasks,” Mar 2025, arXiv:2503.14499.

As intelligence rises, more of VV comes from II, and the remaining platform term shifts toward its agent-facing half. A product with a beautiful interface and mediocre intelligence is now competing for the share of use that still comes from humans, and that share is the one shrinking.


Seats Become Calls

The way software is priced is the clearest sign of who the industry thinks the operator is. Most business software is sold per seat: a monthly price for each person who logs in. A seat is a proxy for usage that works only while each unit of usage needs a person in a chair.

When an agent does the work, the proxy breaks in both directions. One person with an agent can do the work of several seats, so the vendor under-charges. And the work an agent does on its own, at three in the morning with nobody logged in, has no seat at all. The natural replacement is to price what the software actually does: per call, per task, or per outcome.

This is already happening where agents first took over a whole job. Intercom’s Fin, an AI customer-service agent, is priced at USD 0.99 per outcome, where an outcome is, for example, a resolved conversation or a defined handoff to a person, rather than per seat.

Citation: Fin pricing, fin.ai/pricing, retrieved Nov 2026.

Pricing per call or per outcome also changes what the vendor competes on. A seat is sold once a month and judged by whether people like using the product, which is a platform question. A call is sold every time and judged by whether it worked, which is an intelligence question, plus the agent-facing platform’s reliability. The pricing model and the moat move together.


What This Means

For builders. Design the agent-facing platform as deliberately as the human one. Treat the CLI, the API and the tool definitions as a product with its own users: write documentation for models, make every operation safe to retry, return bounded output and errors an agent can act on, and give people narrow permissions and an audit log. Then put the rest of the effort into the intelligence plane, because that is the term that does not depend on who the operator is.

For SaaS incumbents. A moat made of interface polish and learned habits is a moat made of hh. It holds while people operate the product and wears away as their agents do. The parts that survive are the ones agents also value: data no one else has, integrations that took years, reliability, and trust. Pricing per seat will come under pressure from customers whose agents do the work; it is better to choose the unit of value before a competitor does.

For users. Expect to click less and review more. The skill that matters is the one that stays human: saying clearly what you want, judging whether you got it, and deciding how much to delegate.


Open Questions


The graphical interface was a concession to the operator’s limits: people learn slowly, so software learned to show them everything. The operator is changing, and the concession can be withdrawn. What remains is the oldest interface in computing, text in and text out, in front of software whose value lies in how much it understands and how well it acts. The platform still matters. It is just no longer built for us.