Every Action Is an Agent: The New Unit of Software

The fundamental unit of software is changing. Not the interface, not the language, not the architecture diagram — the unit of action itself. Every action software performs is becoming an agent: an autonomous entity that receives a goal, has access to tools, and operates in a loop until the outcome is achieved.

From Fixed Scripts to Goal-Pursuing Loops

For decades, the model was straightforward: a user clicks a button, the button triggers a function, the function runs deterministic logic. Save. Send. Filter. Calculate. Each action is a fixed script doing exactly what it was told.

The replacement isn't "add AI to your app." It's that every action becomes an agent. The difference between an agent and a "smarter function" 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 changes everything about how software behaves.

• A save action might infer the best file format from context, detect conflicting edits, and propose a resolution.
• A send-email action might draft, review, adjust tone based on relationship history, and flag mismatched attachments.

The Unix Parallel: Composable Agents via Universal Protocols

Doug McIlroy's Unix philosophy — write programs that do one thing well and work together — is being elevated. Small, composable agents connect through universal protocols like MCP (Model Context Protocol), introduced by Anthropic in November 2024. MCP is the pipe operator for agents, the same way Unix pipes connected small programs.

Where the analogy breaks: 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 Becomes an Orchestration Layer

A button, a voice command, an API call — these become activation points for agents, not triggers for fixed functions. The activation method is irrelevant to the agent itself. Whether you click "summarize" in a UI, say it to a microphone, or hit a /summarize endpoint, the same agent activates.

This collapses a distinction that's been load-bearing in software design: the difference between manual and automated. In an agent model, the core logic doesn't care who or what activated it. Manual and automated converge at the execution layer.

Why This Isn't Just Microservices Again

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 composition genuinely different this time.

The Infrastructure Is Already There

Non-human identities in enterprise software now outnumber human identities by ratios of 82-to-1 or higher (Rubrik Zero Labs, 2025). Most aren't AI agents yet — they're service accounts, API keys, and bots. But organizations have already built the identity and access infrastructure for a world where software entities vastly outnumber human users. When agents arrive at scale, the pipes are laid.

The Agentic AI Foundation, launched in December 2025 by the Linux Foundation with backing from AWS, Anthropic, Google, Microsoft, and OpenAI, exists specifically to standardize this pattern.

Practical Implications for Builders

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 and self-contained.
• Make actions 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.
• Expect application boundaries to dissolve as agents invoke each other across products.

What Happens to "Apps"?

When every action is an agent that anything can call, an "app" stops being a walled product and starts being a collection of capabilities — published, composable, available to any orchestrator that knows how to ask. If your email agent can invoke someone's calendar agent, which negotiates with a scheduling agent, the boundaries between applications dissolve.

This is analogous to 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 stranger and more useful than anyone predicted.

The Billing Layer: When Agents Compose Across Providers

Once agents compose across providers via MCP and A2A, a new challenge emerges: settling the bill when five agents from three providers each contribute to a single result. The protocol layer handles discovery and communication, but the economic layer -- usage metering, attribution, and settlement -- remains unsolved. This is the next frontier after interoperability.

Standardized connections weaken connector moats

Protocols like MCP make it easier for agents and tools to interact through shared interfaces. That shifts defensibility away from being the only bridge between systems and toward workflow ownership, proprietary operational data, and judgment shaped by repeated use.

Agents as Native AI Architecture

The shift from functions to agents is one expression of a broader pattern: building with AI's native properties rather than forcing AI into existing software forms. When teams move from tools you point and click to collaborators that pursue goals autonomously, they are exploiting what AI actually does well instead of replicating pre-AI software with a language model bolted on. The agent model is what the material wants to become when applied to workflows and team collaboration.