Building an Agent Marketplace: Lessons from App Stores

Nobody wants to build every automation from scratch. If someone has already solved "ingest a PDF, extract the key points, draft a summary email, and send it" -- you should be able to install that chain in thirty seconds and move on to the problem that's actually unique to your business.

We knew early on that Mentiko needed a marketplace. What we didn't know was how hard marketplace design actually is. We studied what worked (and what failed) in npm, Docker Hub, and the iOS App Store before writing a single line of marketplace code. Here's what we took away.

Why marketplaces matter for agent orchestration

The value of an orchestration platform isn't just "you can wire agents together." That's table stakes. The real value is accumulated knowledge -- patterns that other teams have already tested, refined, and battle-hardened.

Without a marketplace, every team reinvents the same chains. A content team at company A builds a research-to-blog pipeline. Company B builds the same thing, slightly worse, because they didn't know the first one existed. Multiply across every use case and the duplicated effort is staggering.

A marketplace collapses that. "We need to automate X" becomes "someone already automated X, let's install and customize it." Weeks become minutes.

But a bad marketplace is worse than no marketplace. If users can't find what they need, can't trust what they find, or can't customize what they install, the marketplace becomes a graveyard of abandoned templates.

What we learned from npm

npm is the gold standard for developer package ecosystems, and a cautionary tale.

Versioning is non-negotiable. npm got semver right. When you install a package, you know what version you're getting. Agent chains need the same discipline. Mentiko chains use semantic versioning: patch for prompt tweaks, minor for new agents, major for breaking changes to the event contract.

Dependencies are the hard part. An npm package can pull in hundreds of transitive dependencies. Agent chains have a similar problem: a chain might depend on a specific model, an external API, or another chain. We track these explicitly in the chain manifest -- no surprises at runtime.

Trust decays fast. npm has a serious problem with abandoned packages -- millions of downloads, zero maintenance. We show last-updated dates prominently and flag chains that haven't been tested against the current platform version.

The long tail is mostly noise. npm has over two million packages. Most are useless. We'd rather have 500 high-quality chains than 50,000 low-quality ones.

What we learned from Docker Hub

Docker Hub solved a different problem: portability. A Docker image runs the same everywhere.

The unit of distribution matters. Docker chose images. npm chose packages. We chose chain templates -- complete multi-agent pipelines with all event wiring, agent definitions, and variable slots included. You don't install half a chain.

Portability requires constraints. Chain templates are portable because they're declarative JSON. No platform-specific code, no hardcoded paths, no embedded secrets. We enforced this at the schema level -- the manifest format doesn't allow non-portable constructs.

Official images build trust. Docker Hub has "Official Images" maintained by Docker or the upstream project. We adopted the same concept: Mentiko-maintained chains that we test on every release. They're guaranteed to work and guaranteed to be maintained.

What we learned from mobile app stores

The App Store and Google Play taught us important lessons -- some about what to copy, some about what to avoid.

Discovery is the whole game. If users can't find your chain, it doesn't exist. We built category browsing, full-text search across chain descriptions and agent prompts, and a "featured" section we curate manually. We explicitly chose not to build algorithmic recommendations yet -- with a smaller catalog, curation beats algorithms.

Ratings need volume to be useful. A single five-star rating means nothing. We display install counts and "last used" timestamps alongside ratings, so users can distinguish between a chain with 400 installs averaging 4.2 stars and one with a single rating from its own author.

Screenshots sell. Visual previews drive installs. For agent chains, "screenshots" means the chain topology, sample inputs, and sample outputs. Every chain in the Mentiko marketplace shows a flow diagram and example output.

Curation beats algorithms at small scale. Apple's editorial team drives meaningful discovery. At our current scale, hand-picked featured chains outperform any algorithm we could build. We rotate featured chains weekly.

Chain templates as the unit of sharing

Should the marketplace share individual agents, complete chains, or both?

Individual agents are too small. A "code reviewer" agent that works brilliantly in a four-agent pipeline might be mediocre dropped into a different chain. Without surrounding context, it's hard to evaluate.

Complete chains with hardcoded values are too rigid. Nobody's use case matches exactly.

Chain templates hit the sweet spot. A template defines the full pipeline -- agents, events, flow -- but parameterizes the parts that vary. Variables like {TARGET_AUDIENCE}, {OUTPUT_FORMAT}, and {MODEL} let users customize without touching the chain logic. Install, fill in your variables, run. If you need deeper customization, fork it.

We also support "chain fragments" -- partial chains covering a common sub-pattern like "fetch data from API, validate schema, handle errors." Building blocks for people constructing custom chains who want a solid starting point for a specific section.

Trust and verification

Running someone else's agent chain means running someone else's prompts on your data, in your workspace. Our approach has three layers:

Static analysis. Before a chain is listed, we scan it for known anti-patterns: prompts that request sensitive data without justification, agents that emit events outside their declared scope, chains with no error handling.

Community review. Every submission goes through a pull request process. The community can inspect the chain definition, ask questions, and flag concerns before it's merged. Slower than auto-publishing, but the right tradeoff at this stage.

Runtime sandboxing. Marketplace chains run in the same workspace sandbox as your own chains. Agents can only access what you've explicitly granted -- no special permissions for marketplace installs.

We're honest about the limitations. Static analysis doesn't catch everything. Community review depends on engaged reviewers. Sandboxing mitigates but doesn't eliminate risk. Automated chain testing is on the roadmap but not shipped yet.

Monetization models

We looked at three models and landed on a hybrid.

Free and open. Most marketplace chains are free and MIT-licensed. This is the default. If you build a useful chain, share it, and the community benefits. This is how the catalog grows.

Premium chains. Some builders invest significant effort into chains that solve complex, high-value problems -- compliance workflows, data pipelines with error recovery, industry-specific chains encoding domain expertise. These can be listed as paid templates. The builder sets the price, Mentiko takes a percentage. We're targeting 80/20 in favor of the builder.

Platform chains. Chains that Mentiko builds and maintains are free for all paid plans. Part of the platform value, not a separate revenue stream.

We explicitly decided against per-execution fees. If you buy a chain, you own it. Run it a million times. Users hesitating to run a chain because of metered costs is exactly the kind of friction that kills adoption.

Where we are and where we're going

The Mentiko marketplace launched with 40+ curated chain templates across six categories: content, engineering, research, operations, sales, and support. Community submissions are open through the GitHub PR process.

What's coming next: automated testing for submitted chains, chain composition (install two chains and wire them together without editing JSON), and a "remix" feature that lets you fork a marketplace chain with one click and start customizing.

The honest assessment: the marketplace is early. The catalog is small. Discovery works because there are only a few dozen chains -- when there are thousands, we'll need better tooling. The trust model is manual and doesn't scale indefinitely. Premium monetization is unproven.

But the foundation is solid. Chain templates are the right unit of sharing. Declarative JSON is the right distribution format. Review plus sandbox is conservative in the right ways. And the ecosystem is growing.

Marketplaces are network-effect businesses. Every chain added makes the platform more valuable. Every install validates the builder's work. Every builder who sees traction is motivated to build more. We're at the beginning of that flywheel, building it deliberately -- quality first, scale second.

Browse the marketplace at mentiko.com/marketplace, or check out the submission guide to publish your first chain.