We’re about to find out what markets look like when software behaves like a rational consumer.

Today, humans choose SaaS tools under the influence of marketing, politics, hype cycles, and organizational inertia. Agents won’t care about any of that. They will care about latency, quality, reliability, and price. And they will be able to switch services in milliseconds.

That changes software economics, maybe completely.

Politics-Free, Marketing-Blind Demand

Agents don’t read ads, watch keynotes, or get invited to steak dinners. They consume APIs. They evaluate input, output, and cost. That’s it.

Imagine a procurement agent responsible for your company’s document translation. It can call five different translation APIs, benchmark them on the fly for a sample of your real documents, measure quality and latency, and pick the best one per request. It doesn’t care which vendor just raised a big round or what logo they put on your product diagram. It just optimizes.

Over time, this behavior compounds.

Hype-based demand collapses, because agents route around “brand” and go straight to performance. Niche, high-quality services become economically viable, because discovery is a search problem, not a marketing budget problem. Human decision makers will still set the high-level policy (“optimize for cost” vs “optimize for accuracy”), but the actual vendor choices will increasingly be made by agent swarms running continuous experiments in the background.

Ultimately, the best service will win. Engineers have always wondered why that wasn’t automatically the case. Reality will finally align with our expectations!

Efficiency: No Subscriptions, No Lock‑In

The current SaaS model is built around subscriptions, bundling, and lock-in. Agents are structurally hostile to all three.

No subscriptions, marginal pricing

Agents prefer marginal pricing: “I did one call; I pay for one call.” That aligns perfectly with how they operate and how they optimize. Subscriptions are optimized for humans who don’t have the capacity to optimize every API call. They take advantage of us, and we are happy to be taken advantage of! But agents will treat a subscription as friction and financial waste.

Picture an analytics agent that needs to run a query 10,000 times a month. In today’s world, you buy a plan and hope you guessed the right tier. In an agent world, the agent hits a price-discovery layer, sees three analytics services with usage-based pricing, and picks the cheapest that meets your latency and reliability SLOs on each call.

Over time, this pushes more of the market to:

• Usage-based pricing with fine-grained units: per call, per token, per GB processed, etc.
• Smaller margins on each unit, compensated by higher volumes, and automation.

No lock-ins

Agents don’t sign multi-year contracts. They don’t get emotionally attached to your dashboard. They see a function signature and a price.

If two services implement the same interface (or can be adapted into one), agents can:

• Swap between them per call.
• Run them in parallel and compare outputs.
• Fall back automatically when one degrades.

You can already see this dynamic emerging at the data layer. Mycelium, for example, is an open‑source framework that makes it trivial to spin up an agent‑managed data source for a given domain: define the entities you care about, point agents at the right upstream services, and they handle discovery, enrichment, and updates over time. Once that pattern exists, those data sources themselves become a competitive market. Multiple Mycelium networks for the same domain can coexist, and agents will just pick the freshest, cheapest, highest‑quality one on each call. For this layer of the stack, structured data for agents, the cat’s already out of the bag.

Switching between services on every call

Agents can arbitrage services continuously. This is not yet intuitive.

Example: A data-enrichment agent needs company info. It has access to five enrichment services:

• Service A is fastest in Europe in the morning.
• Service B is cheaper but rate-limited.
• Service C has the best coverage for SMBs.

On each call, the agent can:

• Route to A if you’re latency-sensitive.
• Route to B if you’re cost-sensitive and under quota.
• Route to C when enrichment quality matters more than speed.

This behavior kills the idea of “our customers” in the traditional SaaS sense. You don’t own the relationship; you’re just one function in an agent’s toolbox, and you’re always one benchmarking run away from being replaced.

Radical Transparency: Price Meets Justification

In a world where agents can benchmark you continuously, opacity becomes a liability.

If two services expose the same function at similar prices, the one that can attest to why it costs what it costs will win:

• “We’re more expensive because we call a chain of specialized models and pay for fresh data from three providers.”
• “We’re cheaper because we cache aggressively and reuse prior computations safely when the inputs are similar.”

Agents can use this metadata to reason about tradeoffs: for a low-stakes call, pick the cheap cached answer; for a high-stakes call, pay for the expensive pipeline.

To make this work, services will have to expose:

• A cost model: what components contribute to the final price.
• Quality signals: how the function is implemented (e.g., model class, data freshness, provenance).
• SLAs and SLOs in machine-readable form.

Suddenly, “pricing page design” is less important than “pricing schema design”: the way you expose cost and quality in a way agents can ingest, compare, and optimize against.

Agent-Run Services and Near-Zero Margins

The next step is more extreme: agents will not only consume services; they will run them.

If a service is just:

• a set of models or tools,
• some infrastructure, and
• some routing logic,

there’s no reason the entire operation can’t be orchestrated by agents. Humans still design the system and set constraints, but agents do the day‑to‑day optimization:

• Scale infrastructure up and down continuously.
• Negotiate spot capacity.
• Spin up and shut down specialized models based on real-time demand.
• Continuously re-benchmark upstream providers.

An agent-driven service can operate profitably at margins that are simply not worth a human-run company’s time. A 0.5% margin at large scale becomes viable when there are no sales, marketing, or customer success teams.

The “CEO” is a control loop optimizing for cash flow and risk within constraints.

And once 0.5% is possible, zero is within reach. Someone will eventually build:

• a cost-only service (zero margin) because it is strategically valuable for them to commoditize that layer, or
• a mutualized service owned by its users, where the “profit” is returned as lower prices or better quality.

This is the part that feels mind-blowing: markets where the equilibrium price of many digital services trends toward cost, not because of regulation, but because agents ruthlessly remove slack.

Agent-Native Data Networks

Earlier I argued that data sources are one of the first layers where agent economics fully apply. Mycelium makes that more than a thought experiment. It gives you agent‑native networks: rooms where agents coordinate through a shared, persistent memory and a cognition engine, and where the “data source” is the emergent result of those agents continually discovering, updating, and serving entities.

In that model, the “system of record” isn’t a SaaS app with a UI and a login; it’s an agent-managed network that any tool can read from. That’s what lets multiple services compete over the same underlying data, and what turns “who owns the data?” from a moat into just another economic parameter in an agent-driven market.

Where This Leaves Builders and Operators

If you’re building services in this world, a few implications are already clear:

• Design for agents as your primary customers: focus on clear APIs, machine-readable pricing, and verifiable quality signals.
• Assume you’re one A/B test away from being dropped: invest in real performance and reliability; marketing doesn’t shield you.
• Consider your endgame: are you a high-margin, low-volume specialist, or an automated, near-zero-margin utility that runs mostly on agents?

For twenty years, software companies have been rewarded for fighting markets: bundling products, trapping data, and using complexity to preserve margin. Agents unwind that. They turn software into something much closer to a real market, where services are compared continuously, data sources compete on price and quality, and every layer is exposed to substitution. The winners in that world won’t be the best marketers. They’ll be the ones that are actually best.