I deployed a Python agent to the cloud in 45 seconds. Here's how.

Last week I built a small Python script that takes a URL and summarizes the page using Claude. Ran it locally, worked great. Then I needed to share it with a colleague who doesn't have Python installed, doesn't know what a virtual environment is, and definitely isn't going to clone a repo.

This is a problem I keep running into. You build something useful in 20 minutes, then spend the rest of the afternoon figuring out how to let other people use it. Docker? Overkill for a single script. A Flask app with a frontend? Now you're maintaining two things. Throw it on a VM? Cool, now you're ops.

I wanted something simpler: take my Python function, make it available at a URL with a UI that anyone can use.

So I built it.

The script

Here's the actual code. A URL summarizer that lets you pick the output style:

import requests
from anthropic import Anthropic

def run(url: str, style: str = "bullets") -> dict:
    page = requests.get(url).text[:4000]
    msg = Anthropic().messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{"role": "user", "content": f"Summarize this page as {style}:\n\n{page}"}]
    )
    return {"summary": msg.content[0].text}

That's the whole thing. A run() function that takes inputs, does something, returns a dict.

The deploy

npx floom deploy summarizer.py

That's it. No Dockerfile. No YAML. No CI pipeline. Floom reads the script, figures out the dependencies, tests it in a sandbox, and deploys it.

You get back a live URL: dashboard.floom.dev/a/url-summarizer

What you get

That URL gives you:

• A web UI with typed input fields (the url and style parameters become form fields automatically)
• A REST API you can call from other services
• Managed secrets, so your API keys aren't in the code
• Version history and rollback

The person I needed to share this with opened the link, pasted a URL, hit run, and got a summary. No setup, no install, no "can you pip install this first."

How it works under the hood

Floom looks at your run() function signature and builds a manifest: what inputs it needs, what types they are, what it returns. It spins up an E2B sandbox, installs your dependencies, runs a test to make sure nothing explodes, then deploys it.

Your secrets (API keys, tokens) are encrypted and injected at runtime. They never touch the code or the manifest.

The whole thing is built on Convex for the backend and E2B for sandboxed execution. Your code runs in isolated containers, not on some shared server.

Why I built this

I kept watching the same pattern: someone builds an AI agent or automation that's genuinely useful, and it lives on their laptop forever because the gap between "working script" and "thing other people can use" is absurdly wide.

The tools exist to close that gap, but they're all designed for production engineering teams, not for someone who wrote a useful script on a Saturday.

Floom is the production layer for AI agents. You write Python, it handles everything else.

It's open source

The whole thing is MIT licensed. The repo is at github.com/floomhq/floom.

You can deploy from Claude Code, Cursor, or any MCP-capable agent. Tell your agent "deploy this on floom" and it knows what to do.

Try it

If you've ever built something useful that's stuck on your laptop, check out floom.dev. It's open source, and deploying your first script is free.