Floom: A Unified Protocol and Runtime for the Agent Era—One-Click Deployment to MCP, API, and Web

Floom is an open-source Agent protocol and runtime that allows developers to deploy Agents, workflows, and scripts as MCP servers, HTTP APIs, and shareable web forms simultaneously using a single configuration file. This article deeply analyzes its architectural design, core features, and practical application scenarios.

With the rapid advancement of Large Language Model (LLM) capabilities, Agent-based applications are moving from proof-of-concept to production environments. However, the current Agent ecosystem faces a core pain point: the fragmentation of deployment methods. Developers often need to maintain multiple interfaces for the same set of Agent logic: user-facing web interfaces, API endpoints for other Agents to call, and server endpoints compliant with the Model Context Protocol (MCP) standard. This redundant work not only increases maintenance costs but also hinders the interconnection of the Agent ecosystem.

The Floom project emerged in this context. It proposes a new approach: using a unified protocol and runtime to allow the same set of Agent logic to provide services externally in multiple forms simultaneously. This article will deeply analyze Floom's architectural design, core features, and its potential value in the Agent ecosystem.

Floom is an open-source Agent protocol and runtime, whose core concept can be summarized in one sentence: "One manifest, three surfaces" (one configuration, three forms). Developers only need to write a YAML-formatted application manifest, and Floom can automatically generate and host three service forms:

1. Web form interface (/p/:slug): Provides a user-friendly interactive interface for end users
2. MCP server (/mcp/app/:slug): For other AI Agents to call via the MCP protocol
3. HTTP API endpoint (/api/:slug/run): For integration with traditional applications

This design greatly lowers the deployment barrier for Agent applications, allowing developers to focus on business logic itself rather than infrastructure setup.

Floom's configuration is based on the widely adopted OpenAPI specification. Developers only need to provide a URL for the OpenAPI spec, and Floom can automatically parse the operation definitions within it and convert them into form fields or MCP tool input parameters. This design brings several notable advantages:

• Standardization: Reuses existing API documentation standards, no need to learn new configuration formats
• Automatic generation: Parameter types, required fields, default values, etc., are automatically mapped to front-end forms
• Ecosystem compatibility: Any tool that supports OpenAPI can understand and generate Floom configurations

Floom supports two deployment modes to adapt to different application scenarios:

Proxied Mode: Wraps existing external APIs. For example, you can wrap the Resend email API into a Floom application, add authentication and rate-limiting layers, and then provide it to the team in a safer and more user-friendly way.

Hosted Mode: Floom directly runs your Docker container. This mode is suitable for applications that require custom logic; Floom handles container lifecycle management, log collection, and scaling.

Floom has multiple production-grade features built into the protocol layer, rather than as post-hoc add-ons:

• Authentication mechanism: Supports both Bearer Token and API Key authentication methods
• Rate limiting: Allows separate rate-limiting policies to be configured for each operation
• Secret injection: Sensitive information (such as API keys) is securely injected via environment variables and not exposed in configuration files
• Run history: Each call is recorded for easy auditing and debugging
• Result sharing: Supports generating shareable output page URLs

Floom's native support for MCP (Model Context Protocol) has far-reaching strategic significance. MCP is an open standard proposed by Anthropic, designed to allow AI models to safely access external tools and data sources. By exposing each application as an MCP server, Floom is effectively building a composable and discoverable Agent capability marketplace.

More cleverly, Floom also provides four MCP management tools: ingest_app (add application), list_apps (list applications), search_apps (search applications), get_app (get application details). This means Agents can discover and call other Agents via the MCP protocol, forming a true Agent collaboration network.

Floom clearly targets two user groups:

1. Vibe-coder creators: Independent developers who want to quickly turn weekend projects into shareable products. They can paste an OpenAPI URL and publish an application with a form interface and MCP endpoint in a few minutes.

2. Enterprise operation teams: Business users who need internal tools and productivity applications. Floom allows them to wrap Stripe-like APIs, create forms that operation teams can fill out, while maintaining clean displays of run logs and outputs.

This dual positioning reflects a key trend in Agent applications: technical boundaries are blurring. Non-technical personnel can also use powerful Agent capabilities through user-friendly interfaces, while developers can perform deep integration via standardized protocols.