The App Marketplace

Part 14 of the [VIMS Blog Network](00-vims-convergence-point). Where finished AI-native applications are published, discovered, and installed.

Part 14 of the VIMS Blog Network. Where finished AI-native applications are published, discovered, and installed.

The Distribution Problem

You built an app with the VIMS SDK. It uses agents for reasoning, P2P for connectivity, the knowledge base for data, and flows for automation. It works on your machine. Now what?

In most ecosystems, distribution is a separate problem from development. You build the app, then you figure out hosting, deployment, updates, and discovery. You set up a website, configure CI/CD, manage a registry, and hope people find it.

VIMS integrates distribution into the platform. The App Marketplace is where finished AI-native applications (built with the SDK, powered by agents, connected via MCP) are published, discovered, and installed. It is the final layer of the VIMS platform loop.

Apps vs. Agents

The VIMS ecosystem has two marketplaces, and they serve different purposes:

The Agent Marketplace (Blog 10) trades autonomous agent NFTs: ownable, monetizable entities with identity, wallets, and reputation. You hire an agent for a task or invite it into a team.
The App Marketplace trades complete applications: deployable software packages with UIs, tools, and capabilities. You install an app on your VIMS instance and use it as a surface.

An app may use one or more agents. An agent may be used by one or more apps. They are complementary: agents are the intelligence layer; apps are the experience layer.

The App Manifest

Every app is defined by a manifest: a structured document that declares:

ID: a unique identifier for the app
Name: human-readable display name
Version: semantic version for update management
Description: what the app does
Entry point: the React component that renders the app
Permissions: what VIMS capabilities the app needs (meeting access, KB search, agent dispatch, database access, P2P, etc.)
Capabilities: what the app provides (custom tools, custom surfaces, MCP endpoints)
Required VIMS version: minimum platform version for compatibility

The manifest is validated against the SDK schema at registration time. If the manifest is invalid (missing required fields, unknown permissions, incompatible version), the registration fails with a clear error listing the violated fields.

Compatibility Checking

Before installing an app, VIMS checks compatibility:

Version compatibility: the app's required VIMS version is compared against the target instance's version
Capability availability: the app's required capabilities are checked against what the target instance supports
Permission validity: the app's requested permissions are validated against the platform's permission schema

If any check fails, the installation is blocked with an explanation. This prevents installing an app that will not run, with no silent failures and no broken surfaces after install.

The Install Lifecycle

Installing an app is a one-step operation:

Browse the marketplace: discover apps by category, search, or recommendation
Review the manifest: see what permissions the app requests, what capabilities it needs, what version it requires
Install: the app's manifest is registered with the platform, its assets are downloaded, and its entry point is available as a surface
Use: the app appears in the VIMS navigation; click it to open

Installation does not require a restart. The app is hot-loaded: its manifest is registered with the app registry, and its entry point is immediately available. The app rescan operation re-hydrates the registry from disk, so apps installed by copying files (without going through the marketplace) are also picked up.

Updates

When an app publisher releases a new version:

Update check: VIMS periodically checks installed apps for available updates
Update notification: if an update is available, the user is notified with the current version, the new version, and what changed
Apply update: the user applies the update; the new version is downloaded and registered
Fallback: if the update fails, the previous version remains installed, with no broken state

Updates are per-app, not per-platform. You can update one app without touching others. The platform version and the app versions are independent.

Uninstalling

Uninstalling an app removes its manifest from the registry. The app's user data (if any) is preserved on disk, so uninstallation is reversible. If you reinstall the app later, your data is still there.

App Categories

The marketplace supports categories for organizing apps:

Productivity: project management, task tracking, document collaboration
Data: database dashboards, KB explorers, data visualization tools
Communication: team chat enhancements, meeting tools, channel integrations
Automation: flow templates, workflow builders, scheduling tools
Development: code tools, testing frameworks, deployment helpers
Research: literature review, data analysis, report generation
Creative: content generation, media editing, design tools

Categories make it easier to discover relevant apps. A user looking for a database tool browses the Data category; a user looking for a meeting enhancement browses Communication.

Permissions and Capabilities

Every app declares what it needs and what it provides:

Permissions (What the App Needs)

Meeting access: join meeting rooms, add agents, inject audio
KB access: search, index, and manage knowledge base documents
Database access: query connected databases, execute SQL
Agent dispatch: start, stop, and communicate with agent instances
P2P access: join team rooms, access shared surfaces
Channel access: send messages through configured channels
Flow access: create, run, and monitor flows
MCP access: invoke MCP tools
File system access: read and write files in the workspace

Permissions are granted at install time. The user sees what the app requests and decides whether to proceed. An app that requests database write access but does not explain why is a red flag; an app that requests only KB search is low-risk.

Capabilities (What the App Provides)

Custom tools: tools that agents can invoke (registered via the tool registration API)
Custom surfaces: UI components that render within VIMS
MCP endpoints: programmatic access to the app's functionality via MCP (Blog 05: MCP Connectors)

Capabilities make apps composable. An app that provides a custom tool can be used by other apps' agents. An app that provides an MCP endpoint can be used by external agents. The marketplace is a composition surface.

Flow Templates as Apps

Flow definitions can be published as apps. A flow template is a pre-built workflow that users install and configure with their own parameters. Examples:

Lead research flow: when a new lead is added to the database, research the company and post a summary to the team chat
Daily standup flow: every morning, query the team's kanban board, summarize progress, and post it to the channel
Customer support flow: when a support ticket is created, dispatch an agent to investigate and post the response

Flow templates make automation shareable. Instead of building a flow from scratch, you install a template, configure it with your specifics (which database, which channel, which agent), and it runs. (Blog 11: Flow and Teams)

The Platform Loop

The app marketplace completes the VIMS platform loop:

Build with the SDK → Publish to the marketplace → Install on any VIMS instance → Compose with agents, flows, and teams

Build: use the SDK, Coder, and Terminal to create an AI-native app (Blog 12: SDK, Coder, and Terminal)
Publish: package the app and list it in the marketplace
Install: other VIMS users discover and install the app with one click
Compose: the installed app uses agents from the agent marketplace (Blog 10: Agent Marketplace), connects via MCP (Blog 05: MCP Connectors), and participates in teams and flows (Blog 11: Flow and Teams)

This loop is what makes VIMS a platform. You build on it, share what you build, and benefit from what others build. The operating system provides the primitives; the marketplace provides the distribution; the community provides the applications.

Coming Soon

The app marketplace is under active development. The manifest schema, compatibility checking, and install lifecycle are designed. The publishing flow, category system, and update distribution are being finalized. This article will be updated as the marketplace ships.

Previous: Build Anything: SDK, Coder, Terminal Back to: VIMS: The Convergence Point