What is Agent Apps?

Agent Apps is the USB-C for AI tools. One standard interface. Any app. Any AI agent. Any platform.

What it is

Agent Apps is an open protocol and SDK for building applications designed for AI agents. It gives agents tools to act, interfaces to present information, and a full runtime to manage their lifecycle — install, configure, authenticate, run, and scale.

An Agent App can be as simple as a single tool (greet someone by name) or as rich as a full product with screens, forms, charts, real-time events, persistent storage, app-to-app communication, and its own embedded AI agent.

The repo contains:

• An open protocol — message schemas, control and session planes, error codes
• An SDK (@agentapps/sdk) — for building apps with tools, interfaces, events, and storage
• A Station (@agentapps/station) — the server that manages app lifecycle, routing, and secrets
• A CLI (@agentapps/cli) — for installing apps, calling tools, and running a local Station
• 80+ apps in the catalog — Gmail, Slack, GitHub, Notion, Playwright, Stripe, and more

Why it exists

AI agents are powerful reasoners, but they're trapped in a text-only world. They can plan, write, and analyze — but they can't do things. They can't check your calendar, send a Slack message, file a GitHub issue, or pull data from your analytics dashboard.

MCP (Model Context Protocol) started solving this by giving agents a standard way to call functions. But MCP servers are stateless tool providers — they expose functions, and that's it. No install flow. No authentication. No visual interfaces. No lifecycle. No persistence. No way for apps to talk to each other.

Agent Apps fills the gap between "a function the agent can call" and "a real application the agent can use":

How it works

Agent Apps uses a client-server architecture with four layers:

Your AI Client (Claude Code, Cursor, Windsurf, ...)
  │
  │  MCP protocol
  │
  ▼
Gateway MCP (protocol bridge)
  │
  │  Agent Apps protocol (HTTP)
  │
  ▼
Station (lifecycle, routing, secrets, auth)
  │
  │  spawns & manages
  │
  ▼
Agent Apps (Gmail, Slack, GitHub, Playwright, ...)

Tool discovery

1. The Gateway MCP bridge connects to the Station
2. It discovers all installed apps and their tools
3. Each tool is exposed as an MCP tool with the naming convention {app}__{tool} (e.g. browser__browser-navigate)
4. Your AI client sees them as ordinary MCP tools

Tool calling

1. Your AI agent decides to call a tool
2. The MCP client sends a tools/call request to Gateway MCP
3. Gateway MCP translates it to an Agent Apps tool_call message
4. The Station routes it to the correct app instance
5. The app executes the tool and returns a result
6. Gateway MCP translates the result back to an MCP response
7. Your AI agent sees the result and continues

Your AI agent doesn't know anything about Agent Apps. It just sees tools it can call.

What you can do with it

As a user

Install apps from the catalog and use them with your AI client:

• "Check my Gmail for unread messages from this week" — the Gmail app handles OAuth, lists messages, and returns structured results
• "Take a screenshot of my website's homepage" — the Playwright app navigates and captures
• "Create a GitHub issue for this bug" — the GitHub app files the issue with the right labels
• "Send a Slack message to the #engineering channel" — the Slack app posts the message

As a developer

Build your own Agent Apps with the SDK:

• Expose tools with typed parameters and structured results
• Add visual interfaces — cards, tables, charts, forms — rendered natively by the host
• Handle OAuth flows without touching tokens directly
• Emit events to notify the agent of changes
• Use storage for persistence across sessions
• Enable app-to-app communication via intents

As an operator

Run a Station and manage apps at scale:

• Spawn instances on-demand, in clusters, or as single shared instances
• Isolate tenants with per-user secrets and sessions
• Scale with Docker, Kubernetes, or remote Execution Hosts
• Monitor health, handle restarts, enforce backpressure

Where MCP fits

Agent Apps doesn't replace MCP — it builds on top of it.

MCP is the protocol that AI clients (Claude Code, Cursor, etc.) use to communicate with tool servers. It defines how to list tools and call them.

Agent Apps is a higher-level protocol that adds application semantics — lifecycle, auth, interfaces, events, storage, app-to-app communication. It uses MCP as its tool-calling layer via the Gateway MCP bridge.

This means:

• Agent Apps work in any MCP-compatible client — no changes needed
• Existing MCP servers continue to work as-is
• You can migrate from an MCP server to an Agent App gradually

Learn more: Agent Apps vs MCP Servers

The analogy

Think of Agent Apps as USB-C for AI tools.

Before USB-C, every device had its own connector — USB-A, USB-B, mini-USB, micro-USB, Lightning, MagSafe. You needed the right cable for every device. After USB-C, one connector works for everything: laptops, phones, monitors, drives, headphones.

Before Agent Apps, every AI tool integration was a custom MCP server with no standard way to handle auth, UI, lifecycle, or persistence. After Agent Apps, one protocol handles it all — and any AI client can use any app through a single bridge.

Get started