cloudparts

Beam Cloud

Beam’s hosted serverless GPU cloud: decorate a Python function and it runs as an autoscaling endpoint, task queue, scheduled job or agent sandbox, billed by the millisecond, on Beam’s capacity or in your own AWS, GCP or Azure account.

What it is
Serverless functions (FaaS)
Used for
Platform as a service (PaaS)
Type
Commercial product
Made by
Smartshare, Inc.
License
Proprietary (the Beta9 engine underneath is AGPL-3.0)
Facts checked
13 October 2026
Website

What it is

Beam Cloud is the hosted product built on Beta9, Beam’s open-source runtime. You install the beam-client package, put a decorator such as @endpoint, @task_queue, @function or @schedule on a Python function with the GPU, CPU, memory and image it needs, and run beam deploy app.py:handler; beam serve gives a temporary cloud environment that hot-reloads as you edit. A deployment is a version of that code; its containers scale with the work waiting and fall to zero when idle. After a request, an endpoint’s container stays warm for 180 seconds by default, a task queue’s for 10 and a pod’s for 600. Endpoint requests time out after 180 seconds by default and can’t run past 600; functions and task queues get an hour by default.

On top of the runtime, the hosted service adds the workspace, dashboard and billing, a catalog of hosted models behind an OpenAI-compatible API, managed Postgres, Redis, MySQL and MongoDB, sandboxes you create from code and can snapshot and fork, and persistent VMs for agents (a CPU microVM with its own kernel, 4 CPUs, 8 GiB of RAM and 50 GiB of disk by default). Beam runs on AWS and Google Cloud rather than its own data centers, in the United States unless you pick a region or pool. Compute pools reserve machines by the hour, and with Bring Your Own Cloud, Beam’s control plane schedules work onto instances in your own AWS, GCP or Azure account.

Billing runs per millisecond while a container runs, including on_start code and any keep_warm_seconds, but not while Beam finds a machine or pulls your image. On the serverless tier an RTX 4090 costs $0.000192 a second (about $0.69 an hour) and an H100 $0.000972 a second ($3.50 an hour), plus CPU and memory. The free Developer plan allows 5 GPU and 30 CPU containers at once; Team ($89 a month) raises that to 50 and 1,000. Bring Your Own Cloud adds a management fee of $0.019 per vCPU and $0.009 per GB of RAM, per hour, on top of your cloud bill.

Why teams pick it

  • A decorator turns a Python function into a GPU endpoint, task queue or cron job that scales to zero and bills by the millisecond, with no YAML or Dockerfile required
  • Cold-start tooling for big models: on_start loaders, warm containers on demand, and checkpoint restore of an initialized process
  • No lock-in by design: the same code can run on Beam’s capacity, in your own cloud account, or on a self-hosted Beta9 cluster
  • One account covers inference, batch jobs, agent sandboxes with memory snapshots, persistent VMs and managed databases

Watch out for

  • Concurrency is capped by plan: 5 GPU containers on the free plan and 50 on Team; more needs the Growth plan
  • Endpoint requests stop at 600 seconds, so long jobs belong in task queues
  • Serverless GPU capacity isn’t guaranteed: a GPU type the SDK accepts may not be available, and reserved machines bill hourly and renew past their TTL until you release them
  • A small company (five people, per its Y Combinator profile); workspaces have no single sign-on yet and every member has the same permissions

Alternatives

What all serverless functions (faas) have in common →Compare side by side →
Beta9Open sourceThe open-source engine behind Beam’s cloud: decorate a Python function and it runs as an autoscaling GPU endpoint, task queue or sandbox, on Beam or on your own Kubernetes cluster.

How it fits with other technologies

app.py: an open model on an H100 behind an autoscaling endpoint (deploy with beam deploy app.py:generate) · python

from beam import Image, QueueDepthAutoscaler, endpoint

def load_model():
    from vllm import LLM
    return LLM("openai/gpt-oss-20b")  # runs once per container

@endpoint(
    gpu="H100",
    image=Image(python_packages=["vllm"]),
    on_start=load_model,
    keep_warm_seconds=300,
    autoscaler=QueueDepthAutoscaler(max_containers=3, tasks_per_container=1),
)
def generate(context, prompt: str):
    llm = context.on_start_value
    return llm.generate(prompt)[0].outputs[0].text

See it in a real stack

No architecture uses Beam Cloud yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2021–2025

Eli Mernit and Luke Lombardi were college roommates who spent years at hackathons and built a serverless framework to ship web apps quickly. When they started working with AI, they found nothing comparable for putting models on the cloud, so in 2021 they founded Beam, a New York company that went through Y Combinator’s Winter 2022 batch.

They wanted to ship machine learning products without managing servers, Dockerfiles or security groups, and built Beam as the cloud they wanted for themselves. AI containers are large and GPUs expensive, so they wrote a custom container runtime and distributed storage layer to keep cold starts low, and isolated workloads with gVisor.

In November 2023 they published that runtime as Beta9 under the AGPL-3.0 and kept selling the managed cloud on top. In a November 2025 Launch YC post they pitched Beam as an open-source alternative to Modal, with sandboxes for agents next to inference and background jobs. Today the hosted service also offers persistent VMs for agents, reserved compute pools and Bring Your Own Cloud.

Why it’s built this way

Python decorators instead of YAML and Dockerfiles
The founders wanted the experience of their hackathon framework for AI: resources and scaling rules sit next to the function they apply to.
An open-source core under the hosted product
Beam positions itself against platforms that lock customers in, Modal by name; a self-hostable engine lets code move between Beam’s cloud and a cluster you run.
Run on other clouds, including the customer’s
Beam doesn’t operate data centers. Scheduling onto AWS and Google Cloud, or onto a customer’s own account, lets customers spend existing cloud credits and keep data in their account.
Bill only for running time
GPUs are expensive, so Beam scales containers to zero when idle and bills by the millisecond while code runs, not while it finds a machine or pulls an image.

Timeline

  1. 2021

    Eli Mernit and Luke Lombardi found Beam

  2. 2022

    Joins Y Combinator’s Winter 2022 batch

  3. 2023

    Runtime published as Beta9 under the AGPL-3.0, November 15

  4. 2025

    Launch YC post pitches Beam as an open-source Modal alternative with agent sandboxes, November

Sources16 · facts checked 13 October 2026

Improve this page on GitHub