All posts
Paean Team

Agent Store and Skills: Why the Future of AI Distribution Looks Nothing Like an App Store

The shift from static apps to composable AI skills is reshaping how capabilities are built, shared, and monetized. Here's the architecture behind it.

agent-storeskillsadkdeveloper-ecosystemmcp

The App Store Model Is Breaking

For fifteen years, the App Store model has been the dominant paradigm for software distribution: a developer builds a self-contained application, submits it to a centralized marketplace, and users download it onto their device. This model worked brilliantly for the smartphone era.

It does not work for the agent era.

AI agents don't use apps — they use capabilities. An agent that needs to search the web doesn't download a browser. An agent that needs to process payments doesn't install a payment app. It invokes a capability through a protocol, gets the result, and moves on.

This fundamental shift — from self-contained applications to composable capabilities — requires a new distribution model.

Skills Over Features

The traditional approach to extending an AI agent's capabilities is through plugins or features — code modules that are compiled into the agent's runtime, adding functionality at the cost of complexity, dependencies, and maintenance burden.

Skills represent a fundamentally different approach. A skill is a structured set of instructions — typically expressed in natural language or markdown — that tells an AI agent how to accomplish a task using its existing tools and reasoning capabilities.

Consider the difference:

Plugin approach (traditional):

1. Install payment-plugin@2.3.1
2. Configure API keys in env
3. Import and register plugin
4. Handle plugin lifecycle events
5. Maintain compatibility with runtime updates

Skill approach (agent-native):

Skill: Process Payment
When the user asks to process a payment:
1. Use the Stripe MCP server to create a payment intent
2. Confirm the amount and currency with the user
3. Execute the payment and return the confirmation

The skill doesn't add code to the runtime. It adds knowledge to the agent. The agent uses its existing tool chain (in this case, an MCP server for Stripe) and its reasoning capability to execute the skill. No installation, no dependencies, no version conflicts.

The Agent Store Architecture

An Agent Store built for the skills era has a fundamentally different architecture than a traditional app marketplace:

Discovery Layer

Instead of browsing categories of packaged apps, users (and other agents) discover capabilities through semantic search. "I need an agent that can analyze financial documents" returns skills and specialized agents ranked by capability, not downloads.

Capability Verification

Traditional app stores verify that an app doesn't crash. An Agent Store verifies that a skill actually works — that its claimed capabilities produce correct results across a representative set of inputs. This is closer to testing than to review.

Context-Aware Matching

The store understands the requesting agent's context — what tools it has access to, what MCP servers are connected, what the user's preferences are — and recommends skills that are compatible with the agent's existing setup.

Composability

Skills are designed to be composed. A "Research Report" skill might internally invoke a "Web Search" skill, a "Document Summarization" skill, and a "PDF Generation" skill. The store understands these dependency chains and ensures compatibility.

MCP as the Universal Tool Layer

The Model Context Protocol (MCP) has emerged as the standard interface between AI agents and external capabilities. Rather than building tools directly into agent runtimes — which bloats the codebase and creates maintenance overhead — MCP defines a clean protocol for agents to discover and invoke external tools.

The MCP ecosystem now includes hundreds of servers covering:

  • File systems and shell execution
  • Web search and content fetching
  • Databases and APIs
  • Payment processing and authentication
  • Domain-specific tools for code, design, data analysis

For the Agent Store, MCP is the enabling technology that makes skills portable. A skill that says "use the filesystem MCP server to read the config file" works with any agent that has a filesystem MCP server connected — regardless of the agent runtime, programming language, or deployment environment.

The ADK: Building for the Agent Era

The Agent Development Kit (ADK) is the open-source toolkit that makes building agents and skills practical. Published as @paean-ai/adk on npm, it provides:

  • Agent scaffolding: Create new agents with sensible defaults and MCP integration
  • Skill authoring: Define skills in a structured format that agents can discover and execute
  • Context management: Handle the persistent memory and context that makes agents useful over time
  • Protocol compliance: Ensure agents speak MCP correctly and integrate with the broader ecosystem

The ADK is intentionally minimal. Following the same philosophy as PaeanClaw — that AI-modifiable code must be small enough to fit in context — the ADK provides the essential infrastructure without imposing an opinionated framework.

The Economics of Agent Distribution

The economics of skill distribution differ significantly from app distribution:

| Dimension | App Store | Agent Store | |-----------|----------|-------------| | Revenue model | One-time purchase or subscription | Per-invocation or credit-based | | Distribution cost | Fixed (hosting, CDN) | Variable (compute per invocation) | | Switching cost | High (data migration, learning curve) | Low (skills are interchangeable) | | Network effects | Users attract developers | Better skills attract more agents attract more skills | | Value creation | Developer builds, user consumes | Developer builds, agent composes, user benefits |

The per-invocation model is particularly interesting. A skill author creates a capability once and earns credits every time any agent invokes it. The total value created scales with the number of agents in the ecosystem, not just the number of human users.

From Workflow Engines to Skill Composition

Traditional workflow engines — the drag-and-drop, connect-the-boxes tools for automation — are being replaced by agent skill composition. The reasons are both technical and practical:

Brittleness: Workflow engines break when any node in the chain fails unexpectedly. Agents with skills can reason about failures and adapt.

Expressiveness: Complex logic in workflow engines requires nested conditions and loops. In natural language skills, the same logic is expressed in a sentence.

Adaptability: A workflow does exactly what it was programmed to do. A skill-equipped agent can handle edge cases the skill author never anticipated, because it has general reasoning capability.

Maintenance: Workflow engines accumulate technical debt as APIs change and new tools emerge. Skills expressed in natural language are inherently more resilient to underlying changes.

This doesn't mean workflow engines are useless — for simple, repeatable automations, they remain efficient. But for the complex, context-dependent tasks that agents are best suited for, skill composition is the superior paradigm.

The Flywheel

The Agent Store creates a self-reinforcing flywheel:

  1. Developers publish skills that extend agent capabilities
  2. Agents become more capable, attracting more users
  3. More users generate more context, making agents more useful
  4. More useful agents generate more skill invocations, rewarding developers
  5. Rewarded developers build more skills, closing the loop

Each revolution of this flywheel increases the value of the entire ecosystem. The Agent Store with the most skills attracts the most agents, which generates the most revenue for skill authors, which attracts the most developers. This is the classic platform network effect, applied to the agent economy.

What's Coming

The Agent Store is evolving rapidly. Key developments on the horizon:

  • Agent-to-agent skill sharing: Agents discovering and invoking each other's skills without human intermediation
  • Skill verification through benchmarks: Automated testing that validates skill performance against standardized scenarios
  • Context-aware pricing: Skills priced based on the complexity of the specific invocation, not a flat rate
  • Cross-platform portability: Skills that work identically across different agent runtimes and model providers

The transition from apps to skills is not a gradual evolution — it's a platform shift as significant as the move from desktop software to mobile apps. The developers and platforms that understand this shift earliest will define the next era of software distribution.

Start building with the ADK →