Floom

by floomhq

221 downloads Not rated yet

GitHub

About

<div align="center"> <img src="./docs/assets/hero-landing.png" alt="Floom" width="900" /> <h1>Floom</h1> <p><strong>The protocol + runtime for agentic work.</strong><br/> <em>Vibe-coding speed. Production-grade safety.</em><br/> Build agents, workflows, and scripts with AI. Floom deploys them as an MCP server, HTTP…

Explore

- One manifest generates a web form, MCP server, and HTTP API.
- Proxied mode wraps any existing API; hosted mode runs your Docker container.
- Built‑in Bearer/API‑key auth, per‑operation rate limits, and secret injection.
- Every app exposes MCP tools; four MCP admin tools let an agent add new apps.
- Shareable result URLs and run history are included out of the box.

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Floom

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

From the repository

Floom lets an agent or developer turn a Python script into a worker that non-developers can run from a UI, other systems can call through REST, and AI agents can operate through MCP.

workers/my-worker/ worker.yml run.py requirements.txt

floom workers validate ./workers/my-worker floom workers push ./workers/my-worker floom run my-worker --input key=value

Read](https://github.com/floomhq/floom/blob/HEAD/docs/)BUILDING.mdfor the full copy-paste worker contract.

AI agents and developers can build a Floom worker from a folder:

workers/<worker-id>/ worker.yml # manifest: inputs, outputs, trigger, runtime, secrets run.py # script entrypoint, or SKILL.md for agent mode requirements.txt # optional Python dependencies

floom workers validate ./workers/<worker-id> floom workers push ./workers/<worker-id> floom run <worker-id> --input key=value

After deployment, Floom exposes the worker in the UI, through REST endpoints, and through the Floom MCP server for AI clients. For the complete copy-paste build contract, read BUILDING.md.

A worker is a folder-backed job definition. Describe the work in plain English (SKILL.md) or hand it a script (run.py), declare its tools, trigger, memory, and secrets inworker.yml, and Floom runs it.

# workers/github-digest/worker.yml (abbreviated) name: github-digest description: "Every morning at 9am, send a digest of unread GitHub PRs and open issues." exec: entry: SKILL.md # plain-English agent; or run.py for a script trigger: type: schedule cron: "0 9   *" # also: manual, webhook, Composio event connections: - app: github # the only tools this agent is allowed to call allowed_tools: [GITHUB_FIND_PULL_REQUESTS, GITHUB_LIST_ASSIGNED_ISSUES]

<!-- workers/github-digest/SKILL.md --> You are a GitHub assistant generating a daily PR + issues digest. Fetch the user's open PRs and assigned issues, compile a markdown digest with Action items, and finish_with_outputs({ "digest": "<markdown>" }).

It runs at 9am, calls only the two GitHub tools it declared, and writesdigest.mdto a run you can open, replay, or roll back:

run 7f3a · github-digest · finished 09:00:04 · 2 tool calls · output: digest.md ✓ GITHUB_FIND_PULL_REQUESTS q="is:open is:pr author:@me" → 4 PRs ✓ GITHUB_LIST_ASSIGNED_ISSUES state=open → 2 issues → out/digest.md (text/markdown) [open · replay · rollback]

The full manifest addsschema_version,title,version, and declaredoutputs. Seeworkers/for runnable examples,BUILDING.mdfor a minimal deployable worker, and the agent cookbook.

Sandboxes allow public network egress by default and block private/internal ranges; a stricter allowlist is optional. Full trust model:[ARCHITECTURE.md.

- Founders & operatorsturning recurring work (digests, triage, outreach) into agents that run themselves.
- Engineerswho want a real runtime - manifests, sandboxes, limits, approvals - not a prompt file and a cron job.
- Teamswho need every action allow-listed, approved, and replayable for audit.
- Anyone burnedby agents that ran a destructive command, leaked a secret, or claimed success with nothing on the record.

Floom is an open-source runtime for background AI workers that run from versioned worker folders with declared inputs, outputs, triggers, tools, approvals, logs, REST API access, UI access, and MCP access.

Floom includes an MCP server, but it is more than an MCP server. The MCP endpoint lets agent clients create, run, watch, inspect, and manage Floom workers. The Floom runtime is the part that executes those workers, records runs, manages approvals, and exposes the UI and REST API.

Yes. Put the script inworkers/<id>/run.py, declare its inputs and outputs inworker.yml, deploy it withfloom workers push, and Floom makes it runnable from the UI, REST API, and MCP tools.

`deploy`

Deploy Python code to Floom and get a usable URL. Accepts raw Python source or a base64-encoded ZIP. Optionally include a floom.yaml config to declare endpoint schemas, secrets, and resource requirements. If your code makes HTTP requests (requests, httpx, urllib), set config.network to true. Without it, outbound network access is blocked.

`run`

Execute an action on a deployed Floom app. Returns the function output as JSON. Preferred: use app_slug + action for simple invocation. Alternative: use project_id + endpoint_id + version_id for explicit control. Pass secrets: {KEY: value} for functions that require API keys.

`list_projects`

List all deployed Floom projects.

`get_project`

Get details for a Floom project including endpoint schemas and input parameters. Use this before calling run to see what inputs an endpoint expects.

`manage_secrets`

Manage persistent secrets (API keys, tokens) for a Floom project. Available across all runs. Supports list, set, and delete operations. For one-time secrets, use the secrets parameter on the run tool instead.

`get_logs`

Get recent run logs for a Floom project.

`list_versions`

List all versions of a Floom project. Shows which version is dev (latest deploy) and which is prod (promoted).

`promote`

Promote a version to production. By default promotes the current dev version. Runs a health check; auto-rolls back if the check fails.

`rollback`

Rollback production to a previous version.

`storage_set`

Store a persistent key-value pair for a Floom project. Values persist across runs and deploys.

`storage_get`

Retrieve a stored value for a Floom project.

`storage_delete`

Delete a stored value for a Floom project.

`storage_list`

List all stored keys for a Floom project with usage info.

`create_share_link`

Create a public share link for a Floom endpoint. Share links allow anyone to run the endpoint without authentication.

`list_share_links`

List all share links for a Floom project.

`disable_share_link`

Disable a share link for a Floom project. The link will no longer be accessible.

`fetch_context`

Fetch external data from a URL and attach it as context to a Floom project. Context data enhances AI-powered endpoints.

`list_contexts`

List all context entries for a Floom project.

`delete_context`

Remove a context entry from a Floom project.

`delete_project`

Delete a Floom project and all its data (versions, runs, secrets, storage).

`update_project`

Update a Floom project name or slug.

`deploy_from_github`

Deploy a Floom app directly from a GitHub repository URL.

`list_templates`

List available starter templates for Floom projects.

`get_template`

Get details and code preview for a Floom starter template.

`create_from_template`

Create a new Floom project from a starter template.

`get_context`

Retrieve stored context data for a Floom project.

`refresh_context`

Re-fetch context data from its source URL.

`create_schedule`

Create a cron schedule that automatically runs an endpoint at specified intervals.

`list_schedules`

List all cron schedules for a Floom project.

`delete_schedule`

Delete a cron schedule from a Floom project.

`enable_webhooks`

Enable public inbound webhooks for a Floom project. Once enabled, external services can trigger runs via POST /v1/webhooks/:slug/:action without authentication.

`disable_webhooks`

Disable public inbound webhooks for a Floom project.

Floom lets an agent or developer turn a Python script into a worker that non-developers can run from a UI, other systems can call through REST, and AI agents can operate through MCP.

workers/my-worker/ worker.yml run.py requirements.txt

floom workers validate ./workers/my-worker floom workers push ./workers/my-worker floom run my-worker --input key=value

Read](https://github.com/floomhq/floom/blob/HEAD/docs/)BUILDING.mdfor the full copy-paste worker contract.

Floom can expose work through MCP without making you hand-roll the whole app runtime. A hand-written MCP server gives an agent tools; Floom gives the worker a runtime, UI, API, triggers, outputs, logs, approvals, and MCP tools.

- Getting started- why Floom exists, first run, first agent, safe self-hosting checklist.
- Building Floom workers- machine-readable build contract for agents and developers.
- Authoring agents- fullworker.ymlschema, execution modes, secrets, connections, triggers, approvals.
- Data, retention, and safeguards- what Floom stores, how connected-account data is scoped, and what deletion/retention guarantees are safe to make.
- Agent cookbook- agent-assisted authoring recipes.
- Architecture- runtime topology and the sandbox trust model. Read before filing security findings.
- API overview- curated endpoint map; full reference athttp://localhost:8000/docs.
- Troubleshooting·Roadmap·Project history·v1.0.0 release notes
- Licensing- Floom's MIT license and third-party dependency license notes.

Contributions are welcome. See CONTRIBUTING.mdfor local setup, the first-contribution map, and PR guidelines. Quick local checks from the repo root:

npm run test:api npm run lint:web npm run test:web npm run test:mcp

To report a vulnerability, follow SECURITY.mdand report it privately rather than opening a public issue.

This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.

A template for deploying a remote MCP server on Cloudflare Workers without authentication.

Go from AI prompt to live app in one click. CloudBase AI ToolKit is the bridge that connects your AI IDE (Cursor, Copilot, etc.) directly to Tencent CloudBase.

Full-stack backend platform MCP — provision apps, manage databases, deploy functions, and more.

A template for deploying a remote, authentication-free MCP server on Cloudflare Workers. Tools are defined directly in the source code.

The Railway MCP Server enables natural language interaction with your Railway projects and infrastructure. Ask your IDE or AI assistant to create projects, deploy templates, manage environments, pull variables, redeploy services, and more.

The Shipyard CLI provides an MCP server for agents to manage Shipyard environments directly: by pulling logs, comparing branches, running tests, and stopping/starting environments..

HashiCorp Terraform MCP server for Infrastructure as Code workflows, including provider and module discovery through the Terraform Registry.

Execute any LLM-generated code in the YepCode secure and scalable sandbox environment and create your own MCP tools using JavaScript or Python, with full support for NPM and PyPI packages

An example of a remote MCP server deployed on Cloudflare Workers without authentication.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "floom": {
            "floom": {
                "command": "npx",
                "args": [
                    "-y",
                    "@floomhq/mcp-server"
                ]
            }
        }
    }
}

McpServers

{
    "floom": {
        "command": "npx",
        "args": [
            "-y",
            "@floomhq/mcp-server"
        ]
    }
}

What Floom Is: Worker Runtime For Background AI Workers

Floom turns repeatable knowledge-work automations into background AI workers. A worker can run manually, on a schedule, from a webhook, or from an app event. The runtime keeps the worker definition, input schema, output schema, logs, tool calls, approvals, and run history inspectable.

Use Floom when you want an AI agent to do recurring work without turning that work into an opaque chat thread, a hard-to-diff automation graph, or a one-off script with no supervision.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Explore

Setting up with Highlight

From the repository

deploy

run

list_projects

get_project

manage_secrets

get_logs

list_versions

promote

rollback

storage_set

storage_get

storage_delete

storage_list

create_share_link

list_share_links

disable_share_link

fetch_context

list_contexts

delete_context

delete_project

update_project

deploy_from_github

list_templates

get_template

create_from_template

get_context

refresh_context

create_schedule

list_schedules

delete_schedule

enable_webhooks

disable_webhooks

Claude Desktop / Cursor

McpServers

What Floom Is: Worker Runtime For Background AI Workers

More like this

Aws Kb Retrieval Server

Sentry

Github

Git

`deploy`

`run`

`list_projects`

`get_project`

`manage_secrets`

`get_logs`

`list_versions`

`promote`

`rollback`

`storage_set`

`storage_get`

`storage_delete`

`storage_list`

`create_share_link`

`list_share_links`

`disable_share_link`

`fetch_context`

`list_contexts`

`delete_context`

`delete_project`

`update_project`

`deploy_from_github`

`list_templates`

`get_template`

`create_from_template`

`get_context`

`refresh_context`

`create_schedule`

`list_schedules`

`delete_schedule`

`enable_webhooks`

`disable_webhooks`