The Rise of AI Agent Marketplaces: The New App Store

From SaaS to AaaS

Agent-as-a-Service (AaaS) is displacing Software-as-a-Service at the edges. Buyers increasingly don't want tools; they want outcomes — not a project management app but something that keeps the project moving, not an accounting system but something that closes the books. Whether the shift is as total as the pitch decks claim is still open, but the pricing consequences are already visible.

The Marketplace Layer

Every major platform vendor now runs some form of agent directory — OpenAI, Microsoft, Google and Anthropic all publish catalogs, extension stores, or connector registries where third-party agents can be listed and installed. Ignore the published listing counts; they measure enthusiasm, not revenue. The meaningful change is distributional: an agent can be discovered inside the assistant a customer already pays for, which is the structural advantage app stores gave mobile developers.

What's listed there is no longer a set of prompt wrappers. The agents that get paid share a technical shape:

• Memory and persistent state across sessions
• Tool use — APIs, code execution, browsing
• Multi-step planning and execution
• Human-in-the-loop approval gates on anything irreversible
• Usage- or outcome-linked pricing rather than pure seat pricing

Which Agents Actually Get Paid — and Why

Per-agent revenue figures are almost never public, and the numbers that circulate are usually annualized guesses. The useful thing to understand is the structure — three properties show up in nearly every agent people renew. The work recurs: an agent that removes a weekly task compounds, while one aimed at an annual project has to re-sell itself every year. The output is gradeable: a filed return, a reviewed pull request, a resolved ticket. If the output is "insight," the agent competes against the buyer's imagination of how good it should have been. The alternative has a visible price: categories where the status quo is a contractor invoice or an obvious headcount cost convert far more easily than ones where the status quo is a free spreadsheet.

The mirror image explains the failures — infrequent work, ungradeable output, or a cost the buyer never accounted for. None of those failure modes are about model quality, which is why "we'll fix it with a better model" so rarely rescues an agent business.

Category	Why it monetizes	Pricing model that fits	Main failure risk
Code review and PR triage	High frequency, output is a diff a human grades instantly	Per-repo subscription or per-review usage	Noise — reviewers mute it if precision drops
Recruiting and sourcing	Replaces an agency fee with a visible price tag	Per-role or per-hire, outcome-linked	Candidate-experience damage from over-automation
Support and ticket resolution	Deflection is measurable against staffing cost	Per-resolved-conversation	Confidently wrong answers to customers
Finance and bookkeeping ops	Recurring cycle, hard deadlines, paid alternative exists	Subscription with volume tiers	Errors are costly and slow to detect
Research and "insight" agents	Weakest case — output is hard to grade	Usually seat-based, and churns	Buyer can't tell good from plausible

Why Agents Beat SaaS

Traditional SaaS requires a human to operate the software: the buyer pays for access and supplies the labor. An agent supplies some of the labor, which moves the comparison from "is this cheaper than the other tool" to "is this cheaper than the person doing it." That's a far more favorable comparison, and it's the whole commercial argument for the category. It also concentrates the market, because agents accumulate context about a specific customer's patterns — expect winner-take-most dynamics inside each category rather than one general agent winning everything, since the domain knowledge doesn't transfer.

Building a Profitable Agent

If you're building agents, here are the patterns that recur in the ones that survive contact with paying customers:

• Deep integration: don't just call APIs — live inside the workflow the work already happens in, whether that's Slack, email, or a pull request queue
• Progressive autonomy: start with recommendations, graduate to actions with approval, and only then to unattended runs
• Explainability: every action needs a legible reason, because the first bad decision is when the customer decides whether to keep you
• Fallback to human: graceful handoff at low confidence beats a confident wrong answer, every time
• A real moat: accumulated context about this customer's patterns, not the base model — the model is available to your competitors on the same terms

Code review is the clearest live example of all five: tools like CodeRabbit sit inside the pull request, explain each comment, and get judged on precision daily. General-purpose engineering agents like Devin take the harder path — broader scope, harder to grade — which is why that category has been slower to settle.

How Pricing Splits by Category

Agent pricing rarely lands on seats, because seats proxy for human labor and the premise is that fewer humans do the work. What replaces it depends on how measurable the output is:

• Per-task where the unit of work is crisp and countable. Easy to explain and forecast, and it ties revenue to volume rather than headcount.
• Per-outcome where value is attributable — a share of recovered revenue, a fee per hire. Highest willingness to pay, hardest to instrument, and it invites attribution disputes.
• Subscription plus usage where load is spiky: the base covers availability, usage covers marginal inference. The most common shape, because it protects gross margin.
• Success-based where the buyer is skeptical. Excellent for landing accounts, dangerous when failed attempts burn tokens too.

The constraint underneath is the same either way: gross margin is your price minus your token bill, and long autonomous runs consume tokens whether they succeed or not. Model that before launch, not after — we work through it in the token economics of AI products.

Six Months Later: The Marketplace Has Only Grown

By July 2026, the platform catalogs have been joined by agent surfaces inside developer tools themselves. Cursor 3.11, released July 10, 2026, added searchable agent transcripts and a dedicated side chat specifically so teams can audit and reuse the exact runs that solved a problem — turning a team's own history into a private agent catalog. Cursor's agents can run on Grok 4.5, xAI's coding-and-agent-specialized model trained in part on real Cursor usage data and priced at $2/$6 per million tokens (it isn't offered in the EU). Underneath, GPT-5.6 Sol plus its cheaper Terra and Luna tiers give builders a price point for every budget, while Claude Opus 5 and Claude Sonnet 5 are common defaults for agents holding a long-running plan, with Claude Fable 5.1 as the escalation tier above them. Once several run at once, the hard problem stops being the model and becomes supervision — the subject of designing interfaces for agent collectives and how agent swarms divide work.

The Developer Opportunity

This is a real distribution opening, comparable in shape to the early app stores — one developer can assemble a specialized agent on an existing model tier and reach customers through a catalog they didn't have to build. The outcome distribution looks like app stores too: a long tail earning very little, and a few category leaders doing well.

The moat isn't technical; it's domain expertise. The best agents come from people who know the problem well enough to know which mistakes are unacceptable — ex-accountants building finance agents, ex-recruiters building hiring agents, ex-lawyers building contract review agents. That knowledge tells you where the human approval gate belongs, and that placement usually decides whether the product gets trusted.

The Future

Expect agents to keep coordinating with each other, forming ad-hoc teams across tools. The commercial question won't change: someone has to point at what the agent produced and say it was worth more than it cost. Categories where that sentence is easy keep growing; the rest keep churning no matter how capable the models get.