Cloud Parts

Beta9

The 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.

What it is
Serverless functions (FaaS)
Type
Open source
Made by
Beam
License
AGPL-3.0
Facts checked
6 October 2026
Website Source code

What it is

With Beta9 you add a decorator to a Python function, such as @endpoint, @task_queue or @function, and give it an image, CPU, memory and optionally a GPU. The platform builds the container, runs it, and scales the number of containers with the work waiting (for example, 30 queued tasks per container, up to five containers), down to zero when idle. A Sandbox is the same machinery driven from code: an isolated container you start, run commands or LLM-generated code in, snapshot and fork.

Underneath is a Go control plane (a gateway and a scheduler) and workers that run on Kubernetes. Self-hosting means installing its Helm chart on a cluster such as EKS, with CPU and GPU worker nodes, a container registry, and persistent PostgreSQL, Redis and S3-compatible storage. Workers can run each container with plain runc, inside gVisor, or as a Cloud Hypervisor microVM. Beam says a custom runtime, image caching and memory snapshots let containers start in under a second; that is the vendor’s figure, and big model weights still have to load.

Beta9 is what Beam’s hosted product runs on. Beam Cloud adds a managed workspace, dashboard, billing and hosted services, which a self-hosted install doesn’t get automatically; the SDK is the same apart from the package name (beta9 instead of beam). The code is open source under the AGPL-3.0. It is young: the repository started in November 2023, its gateway and worker are still versioned 0.1.x with new tags almost daily, and most commits come from Beam’s own small team.

Why teams pick it

  • One decorator turns a function into an autoscaling GPU endpoint, task queue, scheduled job or sandbox, with scale to zero by default
  • Built for heavy AI containers: image caching, memory snapshots and checkpoint restore to cut cold starts
  • Choice of isolation per worker: runc containers, gVisor, or Cloud Hypervisor microVMs for untrusted code
  • The same code runs on Beam’s hosted cloud or on a cluster you control

Watch out for

  • AGPL-3.0: if you modify it and let others use it over a network, you must offer them your changed source
  • Early-stage: components are still 0.1.x, change almost daily, and depend on a small team at one company
  • Self-hosting is a real platform to run (Kubernetes, GPU nodes, registry, ingress, PostgreSQL, Redis, object storage) and lacks some Beam Cloud features
  • Python-first: the decorator model lives in the Python SDK; the TypeScript SDK covers sandboxes and calling deployed endpoints

Alternatives

What all serverless functions (faas) have in common →
AWS LambdaAWSAWS’s functions service: upload a handler, connect a trigger, and pay per request and per millisecond.Cloudflare Browser RunRenamedCommercialHeadless Chrome on demand in Cloudflare’s network, called Browser Rendering until April 2026: one HTTP call for a screenshot, PDF, Markdown or crawl, or a full browser session driven by Puppeteer, Playwright, CDP or an AI agent.Cloudflare WorkersCommercialFunctions that run in V8 isolates on Cloudflare’s network, close to the user, with almost no cold start.+1 WranglerFissionOpen sourceOpen-source functions on Kubernetes: a pool of warm, generic pods takes your code on the first call, so cold starts stay around 100 ms.workerdOpen sourceThe open-source JavaScript and WebAssembly server runtime behind Cloudflare Workers, which you can run yourself as an application server, a local dev server or a programmable HTTP proxy.Workers AICommercialServerless inference on GPUs in Cloudflare’s network: call one of 50+ open models by name from a Worker binding or a REST API, and pay per unit of GPU work instead of renting GPUs.

How it fits with other technologies

An autoscaling GPU endpoint (self-hosted: pip install beta9, import from beta9) · python

from beam import Image, endpoint
from beam import QueueDepthAutoscaler

@endpoint(
    image=Image(python_version="python3.11"),
    gpu="A10G",
    cpu=2,
    memory="16Gi",
    autoscaler=QueueDepthAutoscaler(max_containers=5, tasks_per_container=30)
)
def handler():
    return {"label": "cat", "confidence": 0.97}

See it in a real stack

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

Luke Lombardi and Eli Mernit, college roommates, spent years at hackathons and built a serverless framework to ship web apps quickly. When they started working with machine learning, they found nothing comparable for deploying models, so they founded Beam in 2021 to build it. The company went through Y Combinator’s Winter 2022 batch.

Beam’s pitch was serverless for AI workloads, where container images are large, GPUs are expensive and cold starts hurt. Rather than run on Lambda or a stock Kubernetes setup, they wrote their own container runtime and distributed storage layer, used gVisor for isolation, and added memory snapshots and GPU checkpoint restore.

On November 15, 2023 the runtime appeared on GitHub as Beta9 under the AGPL-3.0, and Beam began presenting itself as an open-source, self-hostable alternative to Modal. It has since grown sandboxes for AI agents and a microVM runtime, while staying on pre-1.0 version numbers.

Why it’s built this way

Python decorators instead of YAML and Dockerfiles
The founders wanted to ship ML products without managing servers, Dockerfiles or security groups, so the resources and scaling rules sit next to the function they apply to.
A custom container runtime and storage layer
AI images with model weights are large, and pulling them on every cold start is slow. Caching and snapshotting at the runtime level is how Beam keeps start-up times down.
gVisor isolation
Sandboxes run code written by users or generated by LLMs, so containers sharing a host kernel need a stronger boundary than plain runc.
Open-source core under a hosted product
Beam positions itself against platforms that lock customers in: the same code can move between Beam’s cloud and a self-hosted cluster.

Timeline

  1. 2021

    Luke Lombardi and Eli Mernit found Beam

  2. 2022

    Beam joins Y Combinator’s Winter 2022 batch

  3. 2023

    Beta9 published on GitHub under the AGPL-3.0, November 15

  4. 2026

    Still pre-1.0, with gateway and worker tags past 0.1.790

Sources10 · facts checked 6 October 2026

Improve this page on GitHub