The tech industry has a naming problem. Everyone's talking about "AI agents" as if they're a new category of software, something you bolt on next to your existing features. A chatbot here, a copilot there, maybe an autonomous workflow if you're feeling ambitious. But this framing misses what's actually happening. And what's happening is more interesting than what's being sold.

Here's what I keep noticing: the fundamental unit of software is changing. Not the interface. Not the language. Not the architecture diagram on some VP's whiteboard. The unit of action itself. And once you see this shift, the practical implications for how to build software right now become hard to ignore.

For decades, the mental model has been straightforward. Software has features. Features are code paths. A user clicks a button, the button triggers a function, the function runs deterministic logic that a developer wrote line by line. Save. Send. Filter. Calculate. Each action is a fixed script, perfectly predictable, doing exactly what it was told.

That model is dissolving, and the replacement isn't what most people think.

The replacement isn't "add AI to your app." It's that every action, every single thing software does, is becoming an agent. Not a chatbot. An agent: an autonomous entity that receives a goal, has access to tools, and operates in a loop until the outcome is achieved. The save button doesn't just write bytes to disk anymore. It might infer the best file format from context, detect conflicting edits from teammates and propose a resolution, or restructure the content to match a schema it was never explicitly told about. The "send email" action doesn't just fire an SMTP call. It could draft, review, adjust tone based on the relationship history with this specific recipient, and flag if the attachment doesn't match what was discussed in the thread.

What makes these agents and not just "smarter functions" is the loop. A function runs once and returns. An agent pursues an outcome, checks whether it got there, adjusts, and tries again. That difference sounds subtle, but it changes everything about how software behaves.

This isn't hypothetical. It's already the architecture behind the tools gaining traction fastest. Claude Code, for instance, doesn't have "features" in the traditional sense. It has tools: atomic capabilities that an agent orchestrates in whatever combination the situation requires. MCP, the Model Context Protocol that Anthropic introduced and that's seen rapid industry-wide adoption¹, is essentially the universal interface for this pattern. It's the pipe operator for agents, the same way Unix pipes connected small programs that each did one thing well.

The protocol layer is still evolving in public, which is why We're Writing Grammar Before the Language Exists is also worth a read.

That Unix parallel is useful, though imperfect. Doug McIlroy's original insight was that the power of a system comes more from the relationships among programs than from the programs themselves². Individual Unix commands are trivial in isolation. The magic is composition. What's emerging now is the same principle, elevated: small, composable agents connected through a universal protocol. Each agent does one thing. The system's intelligence comes from how they combine. Where the analogy breaks is that Unix pipes are linear and deterministic. Agent composition is loopy, stateful, and uncertain. That's what makes it both more powerful and harder to reason about.

The interface stops being a feature catalog and starts being an orchestration layer. A button, a voice command, an API call: these become activation points for agents, not triggers for fixed functions. And the activation method is irrelevant to the agent itself. Whether I click "summarize" in a UI, say "summarize this" to a microphone, or hit a /summarize endpoint, the same agent activates, pursues the same outcome, uses the same tools.

This collapses a distinction that's been load-bearing in software design for years: the difference between "manual" and "automated." In the old model, a user clicks a button (manual) or a cron job fires (automated). These were architecturally different paths. In an agent model, the core logic doesn't care who or what activated it. A human tapping glass or a scheduling system making an API call, the agent operates the same way. Manual and automated converge at the execution layer, even if they still differ at the edges (authentication, audit trails, error reporting back to humans).

Now, someone could reasonably object: "Isn't this just microservices again? We've heard the composability pitch before." Fair point. SOA and microservices promised modular, recomposable systems too. But there's a crucial difference. A microservice executes a fixed procedure. An agent pursues a goal. You tell a microservice what to do. You tell an agent what you want. The agent decides how. That autonomy is the new element, and it's what makes the composition genuinely different this time.

The numbers suggest this shift is already further along than it feels. Non-human identities in enterprise software now outnumber human identities by ratios of 82-to-1 or higher³. Most of those aren't AI agents yet. They're service accounts and API keys and bots. But they represent something important: organizations have already built the identity and access infrastructure for a world where software entities vastly outnumber human users. When agents arrive at scale, they won't need new plumbing. The pipes are laid. What's changing is what flows through them.

Salesforce's architecture team put it bluntly: applications will evolve from monolithic UIs to back-end services that agents can dynamically call⁴. That's not a prediction about 2030. It's a description of what's being built now. The Agentic AI Foundation, launched in December 2025 with backing from AWS, Anthropic, Google, Microsoft, and OpenAI, exists specifically to standardize this pattern⁵.

What does this mean if you're building software today? Probably something like this: design every action as if it could be called by anything. Not just a human clicking a button. Not just your own front-end. Any agent, any interface, any orchestration layer. Make actions atomic, self-contained, describable. If an action can't explain what it does and what it needs in a way a machine can parse, it's not ready for what's coming.

If you're trying to decide where fixed interface still matters in that future, How much static UI do you need? (A free tool) gives a quick diagnostic.

The deeper question is what happens to the concept of "an app" when its actions are agents that anything can call. If my email agent can invoke your calendar agent, which negotiates with their scheduling agent, the boundaries between applications dissolve. An "app" stops being a walled product and starts being a collection of capabilities, published and composable, available to any orchestrator that knows how to ask.

This feels like the early internet, when the interesting question wasn't "what will websites look like?" but "what happens when everything can link to everything?" The answer turned out to be much stranger and more useful than anyone predicted. The same is probably true here. What happens when every action is an agent that anything can activate? No one fully knows yet. But the builders who structure their work around that question will have a head start on everyone still thinking in features.

Rabbit Hole

  1. Model Context Protocol (MCP) adoption data from the MCP blog (December 2025). The protocol, introduced by Anthropic in November 2024, has become the de facto standard for connecting AI systems to external tools, with broad adoption across the industry, comparable to how HTTP standardized web communication.
  2. Doug McIlroy's Unix philosophy, as summarized by Peter H. Salus in "A Quarter-Century of Unix" (1994). The original insight ("write programs that do one thing and do it well, write programs to work together") remains one of the most influential ideas in software design.
  3. Non-human identity data from Rubrik Zero Labs (November 2025) and Entro Labs (July 2025). The ratio varies by measurement, with some sectors reporting ratios as high as 500-to-1, reflecting the rapid growth of service accounts, API keys, and bots in enterprise environments.
  4. Salesforce Architects, "The Agentic Enterprise: The IT Architecture for the AI-Powered Future." This framework describes how applications decompose into modular services that agents call dynamically, replacing the traditional UI-as-feature-catalog model.
  5. The Agentic AI Foundation (AAIF) was announced by the Linux Foundation on December 9, 2025, with founding contributions including Anthropic's MCP, Block's goose, and OpenAI's AGENTS.md. It aims to provide vendor-neutral governance for agentic AI standards, similar to what the Linux Foundation does for Kubernetes and Node.js.