Agent Marketplace Economics

1 Take rates — what the comparables actually charge

The take rate is the simplest visible metric and the most argued-about. Here is the comparable landscape as of May 2026, with primary sources for every cell.

Headline rates as of May 2026. Tier-dependent values are summarised; specific developer terms vary by jurisdiction, programme, and route to market — always read the source contract.

Why 30% became the App Store ceiling, and why it is no longer the standard

Apple set 30% in 2008 against the prevailing publishing-industry split (which was worse for developers) and held it for over a decade. The 30% number was always partly a regulatory hostage: it was high enough to fund moderation, payments, and global distribution, but low enough that no single developer's lobbying could break the dam. The dam broke anyway. Epic v Apple (2021) forced the anti-steering injunction; the EU Digital Markets Act (in force 2023, gatekeeper obligations from March 2024) forced an alternative-app-store mechanism in the EU; the Small Business Program had already lowered most developers to 15% in 2020. The result by 2026: the headline 30% rate applies to a shrinking share of in-store revenue.

"App Store Small Business Program — Apple has reduced its commission to 15% on paid apps and in-app purchases for most developers earning up to $1 million per year."

The infrastructure floor — what Stripe charges

If you strip a marketplace down to "list, transact, settle, dispute, refund", the floor is whatever the payments primitive costs. Stripe Connect is the canonical reference — 2.9% + 30c on cards in the US, with the platform setting an application_fee_amount on top. Any marketplace whose end-to-end take is below ~5% is effectively passing through Stripe's economics with little of its own value capture. That is fine for a hardware-driven marketplace (e.g., Shopify), but for an agent marketplace where the platform is also funding evaluation, audit, identity verification, and the run-time substrate, ~5% is too low to fund the work. The take rate has to clear the cost of being trustworthy at scale.

The non-transactional comparables — why "0% take" is misleading

Hugging Face's Hub charges no take rate on model downloads — but the substrate is monetised through compute (Inference Endpoints), Pro / Enterprise subscriptions, and Spaces. Anthropic's Connectors directory charges no take rate, but the substrate is monetised through Claude API consumption. These are distribution surfaces over a paid runtime, which is a very different business model from a transactional marketplace. The 75/25 split conversation only applies to the second category; the first category competes on different axes (brand, runtime quality, latency, integration depth).

Where 75/25 lands

A transparent 25% take, no slotting fees, payouts denominated in usage (not impressions or installs), settled monthly through Stripe Connect — that lands cleanly between Salesforce AppExchange and the App Store SBP rate. It funds: evaluation infrastructure (continuous evals on every listed agent), audit-trail integration (per-action provenance), identity and KYC (every developer verified), trust-and-safety (incident response, takedown, rollback), the run-time substrate (multi-tenant isolation, billing, observability), and the marketplace's own liability premium under the EU AI Act and DSA. A take rate below that funds none of this and produces a marketplace that's a directory with delusions; a rate above that funds plenty of theatre but eats developer margin and pushes serious developers toward direct-distribution.

2 Cold start — why agent marketplaces are harder than 2008's App Store

Multi-sided platforms are a specific economic object: Rochet and Tirole (2003) [Foundational, 2003] defined them, Tirole's 2014 Nobel lecture formalised the regulatory frame, and Eisenmann, Parker, and Van Alstyne (2007) [Foundational, 2007] documented platform envelopment as the mechanism by which incumbents eat adjacent platforms.

"Two-sided (or, more generally, multi-sided) markets are markets in which one or several platforms enable interactions between end-users, and try to get the two (or multiple) sides 'on board' by appropriately charging each side."

The applicable canonical operator-grade reference is Andrew Chen's The Cold Start Problem (2021) [Foundational, 2021], whose atomic network framing names the smallest network that can self-sustain. The 2008 App Store had a strong starting condition: iPhone shipped with a captive demand-side audience already paying for content, and a supply-side that already knew how to ship desktop and mobile software. Both sides were habituated; the platform's job was to lower friction.

An agent marketplace in 2026 lacks both habituations:

• The supply side is still being trained. A handful of teams know how to ship a production-grade agent (eval-tested, observable, billable). The rest are shipping prototypes that don't survive a real workflow.
• The demand side does not yet have habituated install-and-use behaviour. "Find an agent in a store and adopt it" is not yet a workflow most users do without prompting from a vendor.
• The unit of value is non-deterministic. An app that crashes does so reproducibly. An agent that hallucinates does so probabilistically. The trust signal that converts a window-shopper to a buyer has to be statistical (eval pass rate, audit-trail completeness) rather than binary (does it install?).
• The pricing unit is unsettled. Per-seat, per-task, per-token, per-success — none of them is the answer the way "per-install + per-month" was for SaaS. A marketplace whose default pricing unit is wrong loses developers to those that get the unit right.

The atomic-network shape for agent marketplaces

Chen's atomic-network test asks: what is the smallest set of users on each side such that the network is self-sustaining? For consumer marketplaces it is sometimes a single neighbourhood (Uber in San Francisco). For B2B SaaS marketplaces it is sometimes a single industry (AppExchange's first Salesforce sales-ops integrations). For agent marketplaces in 2026 the answer is almost certainly a single buyer's primary workflow — the small handful of agents that, taken together, run the buyer's compliance pipeline / accounting close / KYC review / customer-support evening shift. That is why vertical agent substrates beat horizontal ones at the cold-start phase: a vertical can deliver a complete-workflow value to a single buyer cohort before the network exists at scale.

Same-side and cross-side network effects

Same-side network effects in agent marketplaces are subtle. More agents on the supply side do not, on their own, make the marketplace more attractive to buyers — past a saturation point they make discovery harder and quality average down (the same dynamic that makes the App Store search experience worse year-on-year). Cross-side effects are the load-bearing part: more verified buyers attract more committed suppliers, more committed suppliers attract more verified buyers. The marketplace's job is to maximise cross-side network density and resist same-side vanity metrics ("we have 50,000 agents listed!"). On this metric, every public agent marketplace launch in 2025–2026 has so far over-emphasised supply.

Single-homing demand and platform envelopment

Eisenmann, Parker, and Van Alstyne's envelopment thesis applies sharply: whoever owns the user's primary chat or compute surface (OpenAI in ChatGPT, Microsoft in Copilot, Google in Gemini, Anthropic in Claude) can envelop a standalone agent marketplace by bundling agent distribution into their existing surface. This is exactly what 2025–2026 looked like: the chat platforms each shipped their own agent surface (Apps in ChatGPT, Copilot agents, Gemini Gems, Claude Connectors), each treating the agent marketplace as an extension of their chat product rather than as an independent two-sided market. A standalone marketplace has to have a defensible reason to exist on top of those — typically that the buyer's substrate is not chat (it is, e.g., a regulated workflow) and the chat-mediated surface cannot serve them.

3 Trust and quality — the signal that converts

Software marketplaces eventually converge on a small set of trust signals: identity verification of the publisher, a code-signing or attestation signal, a curated review or eval, a usage signal, and a ratings/reviews signal. The relative weight of each is what differentiates marketplaces.

What 1.0 marketplaces used

The App Store from 2008 leant heavily on app review (curation), identity verification (Apple Developer Program), and ratings/reviews. AWS Marketplace leant on identity verification + AWS-account-level commercial relationships. AppExchange leant on Salesforce Security Review (a hard gate). All three relied on user reviews as a major surface signal. None of them had to validate non-deterministic behaviour at the platform level.

What agent marketplaces need

The trust regime that maps onto non-deterministic agents has four layers, each different from the App Store stack:

Synthesised from the AgentsBooks 8-primitives substrate (Identity, Brain, Memory, Knowledge, Friends), MCP Specification, and the comparable trust regimes at App Store / AppExchange / AWS Marketplace.

User ratings and reviews are useful but weight much less than they did in 2010. A non-deterministic agent's tail behaviour is not visible to the average reviewer: the review score is dominated by the agent's median behaviour, not by its 99th-percentile failure mode — which is exactly the failure mode that matters for a regulated workflow. Continuous evaluation, run by the marketplace itself, is what surfaces the long tail.

The role of the marketplace as evaluator-of-record

An agent marketplace whose only quality signal is user reviews defaults to "App Store of agents" — and reproduces every failure mode of consumer app discovery (review farming, vanity downloads, low-quality drift). An agent marketplace whose primary quality signal is its own continuous evaluation is more like a clinical trial registry: the marketplace operator vouches for the listed agent's measured behaviour, and the take rate funds that vouching at scale. The 25% in 75/25 is what funds the eval harness, the audit-trail substrate, the incident-response capacity, and the regulatory surface — none of which a 3% take rate can pay for.

4 Liability — who pays when an agent malperforms

The 2024–2026 regulatory wave reshapes marketplace liability in a way that has not yet been fully priced into agent-marketplace design. Three regimes do most of the work in the EU:

EU AI Act — provider obligations along the chain

The EU AI Act, in force since August 2024 with staggered application, places obligations on providers of high-risk AI systems and on entities that put AI systems into service under their own name. Article 25 [EU AI Act, in force 2024-08-01] codifies how obligations transfer along the chain — explicitly contemplating distributors and importers (which is what a marketplace operator becomes for many agent listings). The implication: a marketplace operator that lists a third-party high-risk agent is not a passive directory; it is part of the obligation chain.

EU Digital Services Act — marketplace operator obligations

The Digital Services Act [DSA, in force 2024-02-17] imposes notice-and-action obligations, traceability requirements ("know your business customer" for marketplace sellers), and transparency obligations on online intermediaries. An agent marketplace is squarely in scope: it intermediates between agent sellers and buyers, and it has to ship the same KYBC / takedown / transparency machinery as a goods marketplace.

Revised Product Liability Directive — software is now a product

The revised EU Product Liability Directive (Directive (EU) 2024/2853) [PLD, in force 2024-12-09] explicitly extends strict liability to software, including AI systems, with member-state transposition by December 2026. A defective agent that causes economic loss can give rise to strict-liability claims against the producer. Marketplace operators that are involved in placing the software on the EU market are within the chain of producers and distributors that the directive contemplates.

The implication for marketplace contract design

Liability in agent marketplaces is shared, and the marketplace contract has to allocate it explicitly. The minimum credible posture:

• Verification at intake. The marketplace verifies the developer's identity, the agent's manifest, and (for high-risk listings) compliance with EU AI Act obligations.
• Continuous evaluation. The marketplace runs evals on its own harness and surfaces results; agents that drift past pre-agreed thresholds get auto-paused.
• Per-action audit-trail. Every agent-mediated action carries provenance suitable for incident response and regulatory inquiry.
• Incident response and takedown. Documented SLAs on takedown after credible report; published transparency reporting per DSA.
• Indemnity allocation. The developer indemnifies the marketplace for claims arising from the listed agent's behaviour up to a cap; the marketplace indemnifies for harms arising from its own substrate (multi-tenancy, billing, identity).

None of this is novel for marketplace operators — Salesforce, AWS, and Apple have all built versions — but the agent-marketplace version is more demanding in two ways: the evaluation has to be continuous (because the agent's behaviour drifts as the underlying model and the world drift), and the audit-trail has to be richer (because a regulator asking "what did this agent do at 03:14 on 2026-04-12?" needs an answer that includes inputs, model version, tools called, and outputs — not just "the agent ran"). The 25% in 75/25 has to fund this; in 2026 it is no longer optional.

5 Marketplace, catalog, registry — they are not the same thing

Half of the confusion in 2025–2026 marketplace coverage is conflation: every distribution surface for agents is being called a marketplace, regardless of whether it transacts. The three shapes have very different economics:

Why the distinction matters

A registry's job is discovery. A catalog's job is curated discovery + frictionless install. A marketplace's job is curated discovery + frictionless install + transactional settlement + liability allocation. The take-rate conversation only makes sense for marketplaces; the trust regime and the regulatory surface look different at each tier.

Operators frequently want to ship a registry (cheap, fast, low-stakes) but call it a marketplace (because that is the prestigious word). The mismatch shows up at the first regulatory inquiry, the first liability claim, and the first cohort of developers asking "where is my payout?". An honest marketplace promise has to be backed by transactional plumbing and liability machinery; an honest registry promise should be sold as a registry.

The 2025–2026 landscape, re-classified

• Anthropic Connectors directory — catalog. Verified by Anthropic; commercial terms (where any) sit between user and connector provider. Substrate monetised through Claude API consumption.
• OpenAI Apps in ChatGPT (formerly the GPT Store) — catalog, with a usage-based payout pilot for top builders that approximates a creator-fund model. Substrate monetised through ChatGPT Plus / Enterprise / API.
• Microsoft 365 Copilot Agent Library / Copilot Agent Store — catalog at launch; transactional path emerging for ISV partners through the Microsoft commercial marketplace.
• Google Agentspace Agent Gallery — catalog, distributed primarily inside Google Cloud commercial relationships.
• MCP server registries (modelcontextprotocol.io, Smithery, Glama, MCP.so) — registries. Pure discovery; commercial terms direct between user and server provider.
• Hugging Face Hub — registry for models and datasets; substrate monetisation via subscription and compute.
• Salesforce AppExchange — marketplace, with Agentforce paid agents now sitting inside its Partner Program economics.
• AWS Marketplace — marketplace, with the SaaS path now extending to AI / agent products.
• Apple App Store — marketplace, agentic content sits inside the existing economics until and unless Apple ships a separate agent surface.
• AgentsBooks — marketplace, transactional, 75/25 split, multi-tenant audit-trail substrate, EU-AI-Act-aware.

Distribution-via-protocol

An interesting fourth category emerged in 2025: distribution via open protocol. The Model Context Protocol [MCP, in force 2025-11-25] specifies an open standard that agents and tools speak to each other. Anyone can ship an MCP server; any compatible client (Claude, Cursor, ChatGPT) can call it. The protocol is now stewarded by the Linux Foundation; the Anthropic Connectors directory is one client of many. The A2A Specification v1.0 [A2A, in force] is the agent-to-agent equivalent. Both are also under Linux Foundation stewardship. Distribution-via-protocol short-circuits the marketplace question for some workflows: you don't need to be in an agent marketplace if your agent is reachable as a standards-compliant MCP server. But the marketplace plays a role MCP cannot — discovery, evaluation, audit, settlement, liability allocation. The two layers are complementary, not competing.

6 Case studies — what each comparable actually teaches

Apple App Store — the regulatory hostage

The headline lesson is not 30%; it is that a marketplace whose take rate becomes politically loaded becomes a regulatory hostage. The DMA forced alternative-store mechanisms in the EU; EC enforcement continues; the Apple side responded with a 17%-or-10% commission plus €0.50 Core Technology Fee structure that critics argue replaced one tax with another. The marketplace operator that does not voluntarily price below its political-pain threshold finds itself priced there by regulators, often badly. AgentsBooks' implication: 25% is below the threshold at which a regulator wants to set the price, and is auditable enough to defend.

Salesforce AppExchange — the security review as moat

AppExchange's 15–25% take is competitive, but the Partner Program's most-defensible feature is the Salesforce Security Review. Apps that pass it carry a quality signal that propagates through B2B procurement. The trust signal is not the rating; it is the gate. For agent marketplaces, the equivalent is the marketplace's own evaluation suite — the set of evals an agent has to pass before being listed. Without a credible eval gate, the marketplace's quality signal collapses to user reviews.

AWS Marketplace — the bundled-commerce path

AWS's 3% listing fee is the lowest on this page, but the marketplace is bundled into AWS billing — buyers commit-to-spend on AWS, draw down through Marketplace listings, and the listing fee is the smallest part of the customer relationship. The lesson for agent marketplaces: a low headline take rate is competitive only if the marketplace controls the buyer's commercial substrate at a higher layer. AgentsBooks does control its tenants' commercial substrate, but the value of bundling has to be weighed against the value of transparent take-rate marketing — at 25% transparent, no slotting, AgentsBooks wants to compete on developer-friendliness more than on hidden bundling.

OpenAI GPT Store — the cautionary tale

OpenAI launched the GPT Store in January 2024 and announced builder revenue in March 2024.

"We're launching the GPT Store to feature creations by our community. We will also launch the GPT builder revenue program. As a first step, US builders will be paid based on user engagement with their GPTs."

By 2025, OpenAI had reframed toward an Apps SDK + Connectors story. Why the GPT Store did not become App-Store-shaped:

• The unit was wrong. A GPT is a system prompt; the value differential vs a base ChatGPT conversation was small for many use cases.
• The trust signal was thin. No eval; user reviews dominated; fork-and-clone behaviour eroded developer incentives.
• The pricing unit was unsettled. Usage-based payouts to top builders look like a creator fund, not a marketplace economy.
• The substrate evolved past it. By 2025 the Apps SDK / Connectors framing pulled distribution toward integration with the user's other tools, not toward a chat-store.

The lesson is not that agent marketplaces don't work. It is that an agent marketplace built on an unsettled unit-of-value, with thin trust signals and no liability machinery, doesn't bootstrap. The fix is not more featured-placement; it is fixing the unit, the trust, and the contract.

Microsoft 365 Copilot Agent Store — the tenant-distribution play

Microsoft's Agent Store launch (May 2025) emphasised tenant-administrator distribution: agents are surfaced to enterprise users through Copilot, gated by the tenant's IT admin, billed through the existing Microsoft commercial relationship. The economics are not "developer pays Microsoft 30%"; they are closer to "ISV closes through the Microsoft commercial marketplace, Microsoft splits revenue per the partner programme, distribution into Copilot is the value-add". This is the classic enterprise-software-marketplace pattern: distribution as a feature of an existing commercial relationship rather than as a standalone consumer surface.

Google Agentspace + Agent Gallery — the cloud-hyperscaler pattern

Google Agentspace with its Agent Gallery follows the AWS-Marketplace shape: distribution sits inside the Google Cloud commercial relationship, agents are surfaced to enterprise buyers, and the take rate is bundled with the cloud-services contract. As with AWS, the headline take rate is small because the buyer relationship is owned at a higher layer.

Anthropic Connectors — the trust-via-Anthropic-verification model

The Connectors directory (Sept 2025) is explicitly a catalog: Anthropic curates and verifies connectors, hosting them as a directory inside Claude.ai. There is no take rate; Anthropic monetises through Claude API and subscription consumption. The trust signal is "verified by Anthropic", and that signal is load-bearing because Anthropic is staking its reputation on the listed connector's behaviour. This is the catalog pattern done well: the catalog operator's reputation IS the trust signal, and the substrate's monetisation is decoupled from the catalog itself.

Hugging Face Hub — the registry done well

The Hugging Face Hub charges no take rate on model uploads or downloads. The substrate is monetised through Pro / Enterprise subscriptions and compute (Inference Endpoints, Spaces). This is the registry pattern at its cleanest: an open repository, an enterprise-friendly subscription, a compute layer that captures the runtime value. The lesson: registries can sustain themselves economically, but only if there is a paid runtime they're a discovery layer for. A registry without a paid runtime is a charity.

Stripe Connect — the unbundled marketplace primitive

Most of the marketplaces on this page settle through Stripe Connect or an equivalent. Stripe Connect's application_fee_amount parameter is, in practice, the ledger-line that defines a marketplace: the platform sets it, Stripe collects the gross from the buyer, settles to the seller minus the fee, and routes the fee to the platform. The marketplace's value capture is exactly the application fee minus the cost of running the substrate. AgentsBooks' 25% sits in Stripe Connect's application_fee_amount as a transparent line item, settled monthly per the standard Connect flow.

7 The AgentsBooks stance — and why 75/25 is the choice

Three claims the rest of this page makes good on:

Claim 1 — A marketplace, not a catalog

AgentsBooks runs a marketplace, not a catalog or a registry, because the buyer cohort (regulated service firms) needs the trust regime, the audit-trail integration, and the liability allocation that only a marketplace operator can credibly stand behind. The take rate funds that. A catalog cannot fund eval-gating; a registry cannot fund per-action audit-trail. Both are useful and both have a place — the AgentsBooks Friends primitive surfaces external connectors via MCP, in a registry/catalog shape — but the substrate's commercial backbone is the transactional marketplace.

Claim 2 — 75/25, transparent, no slotting

The 25% take is set against the comparables: above the AWS/Stripe infrastructure floor (3–5% range), below the App Store SBP / AppExchange ceiling (15–25%). What 25% buys, in the AgentsBooks substrate:

• Identity and KYC of every developer, signed at intake.
• Manifest verification of every listed agent, parsed against the 8-primitive shape.
• Continuous evaluation against AgentsBooks-curated eval suites; auto-pause on regression past pre-agreed thresholds.
• Per-action audit-trail across the multi-tenant substrate (the auditable-substrate property of the platform).
• Incident response and takedown with documented SLAs and DSA-compliant transparency reporting.
• Indemnity allocation per the marketplace contract; explicit allocation across developer / marketplace / buyer.
• Cross-side discovery — buyer-cohort matching, role-aware surfacing, eval-pass-rate-weighted ranking.
• Settlement through Stripe Connect; usage-based payouts; transparent reporting.

Claim 3 — A vertical atomic network

The AgentsBooks atomic network is service firms running on agents (compliance, accounting, KYC, support, legal). The network is self-sustaining when a single buyer's primary workflow is run through agents on the substrate — the cold-start happens at the firm level, then propagates across firms in the same vertical, then across verticals. This is the vertical-marketplace pattern, not the App-Store-of-everything pattern. It's also why the marketplace can credibly run a 25% take: the buyer's cost is measured against the headcount-equivalent cost the agents are replacing, not against the consumer-app pricing the App Store competes on. A 25% take on agent revenue that is replacing $87k loaded FTE cost is a different math from a 30% take on a $0.99 game.

8 Counter-narratives we engage

"Agent marketplaces are unnecessary — distribution is via protocol"

This is the MCP / A2A maximalist position: any agent reachable as an open-standards server is, by construction, distributable. There is real truth in it — the protocol layer reduces the distribution surface from N marketplaces × M chat clients to a single open standard. But the protocol layer cannot do what a marketplace does: gate, evaluate, audit, settle, allocate liability. The two layers are complementary; the marketplace's value capture is exactly the gating, evaluation, audit, settlement, and liability work that the protocol explicitly does not do.

"30% is the right number — the App Store is profitable, after all"

The App Store is profitable in part because Apple bundles distribution into a hardware monopoly. A standalone agent marketplace cannot replicate that bundling and is not in a position to charge 30%. The App Store SBP rate (15%) is closer to the floor of where independent marketplaces can profitably price, and the AgentsBooks 25% is set above that floor to fund the eval and liability machinery the App Store does not have to provide.

"The pricing unit should be per-task, not per-cent-of-gross"

Per-task pricing is interesting but does not displace the take-rate conversation; it changes the unit on which the take is computed. AgentsBooks' v1 pricing unit is per-usage (calls, tokens, agent-minutes) with the 25% take applied to the developer's gross usage revenue. Per-task / per-success pricing is a roadmap item — it produces cleaner buyer-side ROI math but is harder to standardise across heterogeneous agents.

"Liability is a developer problem, not a marketplace problem"

Under EU AI Act, DSA, and the revised PLD, this is no longer correct. Marketplace operators that list third-party AI systems are within the obligation chain. A marketplace whose terms attempt to shed all liability onto developers is not credible at procurement and is not stable under regulator inquiry. The credible posture is shared liability with explicit allocation, backed by verification and continuous evaluation at the marketplace tier.

"Just be a registry — the open ecosystem will distribute everything"

Registries are valuable; AgentsBooks runs registry-shaped surfaces (the Friends primitive, MCP-server discovery). But a regulated buyer cannot transact through a pure registry, because the registry by design does not stand behind the listed agent's behaviour. The registry route maps to commodity tools; the marketplace route maps to mission-critical agents. The two are different products serving different buyers.