Marketplace Take Rates for Third-Party Agents: What Platforms Actually Charge (and Why It's About to Get Messy)

Table of Contents

• What a Take Rate Actually Means in an Agent Marketplace
• Why the 30% App Store Number Doesn't Transfer
• The Three Marketplace Archetypes and Their Economics
• The COGS Problem Nobody Priced In
• What Platforms Are Actually Charging Right Now
• How to Model Your Margin Against a Take Rate
• The Disintermediation Risk That Sets the Ceiling
• Insights Most People Overlook
• References

What a Take Rate Actually Means in an Agent Marketplace

Strip away the jargon and a take rate is a tax on a transaction the platform helped happen. A customer pays $100 for an agent to reconcile their invoices, the marketplace keeps $25, the agent developer gets $75. That 25% is the take rate, and it's the oldest business model on the internet, eBay, the App Store, Uber, Airbnb, Visa all run on it.

What's new is what is being transacted. In a traditional software marketplace, the platform brokered the sale of a license or a subscription. The marginal cost of delivering one more copy of the software was effectively zero, so the take rate was almost pure margin for everyone in the chain. Agent marketplaces broker something different: the sale of work performed. Every time a third-party agent runs, it burns inference tokens, calls tools, maybe hits paid APIs. The transaction has a real, variable cost of goods sold sitting underneath it, and the take rate gets carved out on top of that cost, not instead of it.

This is the structural fact that everything else in this article hangs on, and it's the thing most pricing discussions skip. The take rate in agent commerce is a margin on a margin, and that changes the math in ways that the per-seat and per-outcome pricing debates (worth their own deep dives) only partly capture.

Why the 30% App Store Number Doesn't Transfer

When OpenAI announced its GPT Store, when Salesforce rolled out AgentExchange, when every VC-backed agent platform sketched its business model, the anchor in the room was Apple's 30%. It's the most famous number in software economics. It's also almost entirely wrong as a reference point for agents, for three concrete reasons.

First, distribution scarcity is gone. Apple could charge 30% because it owned the only door to a billion iPhones. There was no second door. An agent marketplace owns no comparable chokepoint, a competent agent can be sold through a dozen marketplaces simultaneously, through a direct website, through an API, embedded in someone else's SaaS, or invoked agent-to-agent with no human-facing storefront at all. When the seller has alternatives, the take rate has a ceiling that scarcity-based marketplaces never faced. Regulators have spent the last few years hammering exactly this point; the EU's Digital Markets Act provisions on app store fees already forced Apple to introduce alternative fee structures, and that pressure landed before agents made disintermediation trivial.

Second, the cost structure inverts. Apple's marginal cost per app sale rounds to zero. An agent marketplace that handles billing, identity, and runtime for a third-party agent is paying for compute on every single transaction. A 30% take on a transaction where 40% of the revenue is already eaten by inference isn't a 30% margin, it can be a loss.

Third, the value is auditable. App store value was diffuse and unmeasurable; you couldn't prove an install was "worth" the cut. Agent outcomes can be measured, task completed or not, ticket resolved or not, invoice matched or not. That auditability invites buyers (and sellers) to ask the uncomfortable question app developers could never make stick: what exactly is the 30% buying me? Once that question is answerable, the take rate has to be justified line by line.

The Three Marketplace Archetypes and Their Economics

Not all agent marketplaces are the same animal, and lumping them together is why so much commentary on take rates is muddled. There are three distinct archetypes, and each supports a very different cut.

The Directory (thin take, 0-15%)

This is the lightest model: the marketplace is a listing and discovery surface, maybe handling the initial billing handshake, but the agent runs on the developer's own infrastructure. The platform provides eyeballs and a checkout button, nothing more. Because it carries no compute cost and underwrites no reliability, its defensible take rate is thin, think referral-fee territory, 0-15%. A directory that charges 30% is charging App Store rates for Yellow Pages value, and sellers will route around it the moment a cheaper door opens.

The Runtime (medium take, 15-25%)

Here the platform actually executes the agent, it provides the hosting, the orchestration, the observability, the sandboxing, and critically it bundles the inference. Now the take rate is doing real work: it covers genuine COGS plus a margin for the operational lift of keeping third-party agents running safely. This is where most serious agent platforms will land, and 15-25% is sustainable because the platform is providing something the developer would otherwise have to build and pay for. The take rate here is partly a cost pass-through dressed as a commission.

The Managed Outcome (fat take, 25-40%+)

The heaviest model: the platform sells the result, stands behind it with an SLA, handles refunds when the agent fails, owns the customer relationship, and treats the third-party agent as an interchangeable supplier behind the curtain. This is closer to how a staffing agency or a general contractor works than how an app store works. When the platform absorbs outcome risk, issuing refunds on failed tasks, smoothing over partial completion, a 30-40% take is not just defensible, it's necessary to fund the guarantee. The agent developer trades margin for de-risked, demand-generated, billing-handled distribution. McKinsey's framing of the economic potential of agentic AI makes the point that value capture flows to whoever owns the workflow and the accountability, not whoever wrote the model call, and the managed-outcome marketplace is explicitly buying that ownership.

The mistake is picking a take rate before deciding which archetype you are. The number is downstream of the value, every time.

The COGS Problem Nobody Priced In

Let's make the margin-on-a-margin problem concrete, because it's the part that quietly kills agent marketplace P&Ls.

Say a third-party agent charges a customer $1.00 to complete a task. Underneath, that task costs $0.35 in inference and tool calls. The marketplace takes 25%, or $0.25. What's left for the developer? Not $0.75, it's $0.75 minus their share of the $0.35 COGS, depending on who's eating the compute. If the developer pays the inference, they net $0.75 − $0.35 = $0.40 on a dollar, with the platform taking nearly as much margin ($0.25) as the person who built the thing ($0.40). If the platform pays the inference out of its $0.25 cut, the platform nets a negative $0.10 and is subsidizing every transaction.

This is not a hypothetical edge case. It's the default situation whenever inference is a meaningful fraction of price, which it is for any non-trivial agent. It's why the question of who absorbs volatile inference costs deserves its own treatment, and why margin-safe pricing is a survival skill rather than an optimization.

The take rate, in other words, can't be set as a flat percentage of gross revenue and left alone. The economically literate marketplaces are already moving to one of three fixes:

• Take on net, not gross, calculate the cut after deducting pass-through compute, so the platform isn't taxing its own COGS.
• Tiered take by margin band, a higher percentage on high-margin agent categories (where price is mostly value, not compute) and a lower one on compute-heavy categories.
• Flat platform fee plus thin transaction take, decouple the cost of being on the platform from the cost of each transaction, which protects the platform from getting squeezed on compute-heavy agents while still capturing upside on volume.

Any marketplace still quoting a single headline take-rate number across all agent types hasn't done the COGS math yet.

What Platforms Are Actually Charging Right Now

As of 2026 the landscape is genuinely unsettled, and anyone quoting precise figures with confidence is guessing. But the rough shape is visible.

Salesforce's AgentExchange and similar enterprise-software marketplaces are leaning on familiar ISV revenue-share economics, a flat fee for the listing plus a percentage cut, with the percentage broadly in the 15-25% band that mirrors their existing AppExchange deals. These platforms have the advantage of distribution into installed enterprise accounts, which is the one place a higher take rate still has teeth, because the alternative door (selling cold into a Fortune 500) is genuinely expensive for the developer.

OpenAI's GPT Store experimented with usage-based and engagement-based payouts to builders rather than a clean revenue-share take rate, which is its own statement: when the platform isn't sure the per-transaction value justifies a percentage cut, it falls back to paying out of a pool. That's a tell that the marketplace doesn't yet trust the take rate to clear.

Consumer-facing and developer-tooling agent marketplaces are mostly clustering at or below the 20% line, because their sellers have the most exit options and the least patience for a fat cut. a16z's analysis of how AI is reshaping software business models repeatedly returns to the theme that value is migrating from seat-based licenses toward consumption and outcomes, which compresses the room a marketplace has to take a flat percentage, because the seller's own margin is now variable and exposed.

The honest summary: 15-25% is the gravitational center for runtime-style agent marketplaces, the edges run from near-zero for thin directories to 35-40% for managed-outcome platforms that underwrite the result, and almost everyone is still repricing.

How to Model Your Margin Against a Take Rate

If you're a developer deciding whether a marketplace is worth it, run this calculation before you sign anything. The take rate is meaningless in isolation, what matters is your take-home margin after both the cut and the COGS.

1. Start from the customer price, not your list price. The marketplace may discount or bundle.
2. Subtract your true COGS per transaction, inference, tool calls, third-party APIs, and a realistic allowance for retries and failed runs that you still pay for but don't bill.
3. Subtract the take rate, and confirm whether it's calculated on gross or net, because the difference can be 10+ points of margin.
4. Subtract the hidden costs of being on the platform, payment processing if it's separate, mandatory support SLAs, certification or review overhead.
5. Compare against your direct-sale economics, including the customer acquisition cost you'd carry without the marketplace's demand.

The marketplace is worth its take rate only if (your margin on-platform) + (the value of demand it generates) exceeds (your margin selling direct) − (your own CAC). For most developers without a distribution engine, a 20% take that comes with real demand beats a 0% take with an empty pipeline. For developers who already own the customer, even a 10% take can be pure leakage. The take rate isn't good or bad in the abstract; it's good or bad relative to your distribution alternatives, which is the same logic that governs channel and reseller economics across the wider agent ecosystem.

The Disintermediation Risk That Sets the Ceiling

Every take rate has an invisible ceiling, and in agent marketplaces that ceiling is unusually low because routing around the platform is unusually easy.

In a human-mediated marketplace, disintermediation has friction, the buyer and seller have to find each other, build trust, and transact off-platform, which is annoying enough that most don't bother. With agents, the "buyer" is often itself an automated system, the "seller" is an API endpoint, and the relationship can be re-established with a config change. Once a customer knows which agent solved their problem, pointing their workflow directly at that agent's API, cutting the marketplace out entirely, is a few hours of integration work, not a leap of faith.

This is the agent-to-agent commerce frontier, and it's why the smart platforms are racing to make themselves more than a billing tollbooth. The marketplaces that will sustain a healthy take rate are the ones that bundle things genuinely hard to replicate: a trust and reliability layer (vetting that an agent does what it claims), a unified billing and dispute mechanism, identity and authentication for autonomous spending, and the demand itself. A marketplace whose only value is "we connected you once" has a take rate ceiling that trends toward zero, because the connection only needs to happen once. A marketplace that is the ongoing system of trust, payment, and accountability can defend a real cut indefinitely.

The take rate, in the end, is a measure of how much irreplaceable value sits between the agent and its customer. Set it above what that value is worth, and you don't get more revenue, you get disintermediated.

Insights Most People Overlook

1. The take rate is a margin on a margin, and that single fact rewrites all the app-store comparisons. Because agents carry real per-transaction COGS, a 30% take in agent commerce is economically heavier than a 30% take in the App Store, where COGS was zero. Anyone benchmarking against Apple's 30% is comparing two numbers that mean completely different things. The right comparison is to payment processors and staffing agencies, not app stores.

2. Auditability is a double-edged sword the platforms haven't fully reckoned with. The same outcome-measurability that lets a marketplace charge a fat managed-outcome take also lets sellers and buyers prove the take is too high. When the value is invisible (an app install), nobody can argue with the cut. When the value is a measurable resolved ticket, both sides can run the math, and that transparency structurally pushes take rates down over time, not up. The most measurable marketplaces will face the most fee pressure.

3. The platform that pays for inference has a fundamentally different, and more fragile, business than the one that passes it through. A runtime marketplace bundling compute into its take rate is implicitly betting that average inference cost stays below its margin. When a popular agent category suddenly shifts to a more expensive reasoning model, that bet can flip negative overnight with no change to the take rate. Pass-through marketplaces are immune to this; bundled ones are exposed. This is an under-discussed reason marketplaces will drift toward pass-through billing even though customers prefer all-in pricing.

4. Take rates will likely split by autonomy level, not just by category. A supervised agent a human reviews before action is low-risk for the platform; a fully autonomous agent transacting unattended carries real liability and demands a trust layer the platform must fund. Expect higher take rates on higher-autonomy agents, not because they cost more to run, but because the marketplace is underwriting more risk. The cut becomes a risk premium, which is a very different logic from a distribution fee.

5. The first marketplace to publish transparent, net-of-compute take rates will win developer trust and pull supply. In a market where everyone is opaque about whether the cut is on gross or net, simple clarity is a competitive weapon. The platform that says "we take 18% of revenue after your compute costs, and here's the dashboard proving it" will attract the best agent developers the way transparent payment processors pulled merchants away from opaque ones. Transparency is an underrated land-grab move while the rest of the field is still hiding the ball.

References

• European Commission, Digital Markets Act
• McKinsey, McKinsey Digital insights on agentic AI and value capture
• a16z, The Future of AI and evolving software business models