---

OpenAPI spec ──▶ Floom ──▶ 3 surfaces
                           ├─ MCP server    (/mcp/app/:slug)
                           ├─ HTTP endpoint (/api/:slug/run)
                           └─ Web form      (/p/:slug)

Launching 2026-04-27. Floom Cloud goes live on April 27. Self-host already works today — one Docker command, full stack. Three AI apps are live now for anyone to try: Lead Scorer, Competitor Analyzer, Resume Screener. Join the waitlist for Cloud.

Install the CLI with curl -fsSL https://floom.dev/install.sh | bash. Do NOT run npm install floom - the unscoped floom npm package is an unrelated third-party streaming tool. Details: cli/floom/README.md.

Point Floom at an OpenAPI spec and you get all three, from the same manifest, with auth, rate limits, secret injection, run history, and shareable output pages. No glue code.

Quickstart

One container, no setup:

docker run -p 3000:3000 ghcr.io/floomhq/floom-monorepo:latest

Or try the live apps at floom.dev/apps — no install. Cloud (publish your own) lands 2026-04-27; join the waitlist. Full self-host walkthrough: docs/SELF_HOST.md.

What it is

Floom is a runtime and a protocol for agentic apps. You describe an app once with an OpenAPI spec; Floom gives you an MCP server an agent can call, a plain HTTP endpoint, and a web form on a shareable URL — all at the same time, all backed by the same auth and rate-limit layer.

The whole stack self-hosts in one Docker container. Source is MIT.

The three surfaces

MCP — any client that speaks Model Context Protocol (Claude Desktop, Claude Code, Cursor, Codex CLI) can call your app as a tool.

{
  "mcpServers": {
    "resend": { "url": "http://localhost:3000/mcp/app/resend" }
  }
}

HTTP — straight JSON-in, JSON-out. Use it from curl, a backend, a cron job.

curl -X POST http://localhost:3000/api/resend/send-email \
  -H "Authorization: Bearer $FLOOM_TOKEN" \
  -H "content-type: application/json" \
  -d '{"from":"[email protected]","to":"[email protected]","subject":"hi","text":"first"}'

Web form — a clean page at /p/:slug your teammates can fill in, with typed inputs, a shareable result URL, and a run history.

https://floom.dev/p/lead-scorer

Who it's for

• Makers shipping side projects. Paste an OpenAPI URL, publish a shareable page, hand your friends an MCP tool.
• Teams running internal tools. Wrap a Stripe-style API in a form your ops team can fill in, with runs logged and outputs rendered cleanly.

Two equal ICPs. Two CTAs on the homepage. Two dashboards (/me for runners, /creator for publishers).

Showcase apps

Three apps shipped with Floom to show what it can do:

App	What it does	Live
Lead Scorer	Scores a CSV of leads with Gemini, ranks them, explains why.	floom.dev/p/lead-scorer
Competitor Analyzer	Takes a list of competitor URLs, pulls positioning + pricing + weak spots.	floom.dev/p/competitor-analyzer
Resume Screener	Scans a batch of resumes against a job description, ranks and flags.	floom.dev/p/resume-screener

Each one is a real OpenAPI-defined app under examples/ — fork, rename, tweak the prompt.

 

Self-host

# apps.yaml — one app, wrapped in 10 lines
apps:
  - slug: resend
    type: proxied
    openapi_spec_url: https://raw.githubusercontent.com/resend/resend-openapi/main/resend.yaml
    base_url: https://api.resend.com
    auth: bearer
    secrets: [RESEND_API_KEY]
    display_name: Resend
    description: "Transactional email API."

docker run -d --name floom \
  -p 3000:3000 \
  -v floom_data:/data \
  -v "$(pwd)/apps.yaml:/app/config/apps.yaml:ro" \
  -e FLOOM_APPS_CONFIG=/app/config/apps.yaml \
  -e RESEND_API_KEY=re_... \
  ghcr.io/floomhq/floom-monorepo:latest

Open http://localhost:3000/p/resend, or point your agent at http://localhost:3000/mcp/app/resend.

Two manifest shapes ship out of the box:

# Proxied — wrap an existing API
type: proxied
openapi_spec_url: https://api.example.com/openapi.json
base_url: https://api.example.com
auth: bearer
secrets: [EXAMPLE_API_KEY]

# Hosted — Floom runs your container
type: hosted
runtime: python3.12
openapi_spec: ./openapi.yaml
build: pip install .
run: uvicorn my_app.server:app --port 8000

A single request header can only carry one auth token, so pick one per deployment: FLOOM_AUTH_TOKEN (operator-wide kill switch) or FLOOM_CLOUD_MODE=true (real user sign-in + per-user API keys). Full breakdown: docker/.env.example.

Full self-host guide: docs/SELF_HOST.md · Protocol spec: spec/protocol.md · More examples: examples/.

Repo layout

• apps/web — floom.dev web surface (React, form + output renderer)
• apps/server — backend (Hono + SQLite + Docker runner + MCP)
• packages/renderer — @floom/renderer, default + custom output/input renderer library
• spec/protocol.md — Floom Protocol spec
• examples/ — example manifests, including the three showcase apps above

Development

pnpm install
pnpm dev

Web on :5173, server on :3051, hot reload on both.

Contributing

Short version: pick an issue labelled good first issue or drop a new example app under examples/. Full guide, including how to add a showcase app: CONTRIBUTING.md.

Community & support

• Discord — discord.gg/8fXGXjxcRz for help, ideas, and patch-of-the-day.
• Docs — floom.dev/docs
• Issues — github.com/floomhq/floom/issues for bugs, feature requests, docs gaps.
• Security — read SECURITY.md, email [email protected].

License

Floom is released under the MIT license. Use it at work, use it at home, fork it, sell products built on top of it. If you ship something cool, we'd love to see it in the Discord.

---

Built in SF by @federicodeponte.