2026-10-11 16:37 UTC

Beam Cloud claims its publicly available Beta9 runtime provides self-hostable serverless GPU inference and isolated code sandboxes with sub-second container starts, potentially replacing managed-platform dependence with a Kubernetes-operated AI execution stack.

state: seedheat: mediumuncertainty: mediumconvergesscott: mediumai-infrastructure inference-serving sandboxingBeam Cloud

What is this?

Beta9 is Beam Cloud’s publicly available, AGPL-3.0 runtime powering its managed platform, combining serverless GPU inference, isolated code-execution sandboxes, background jobs, and scale-to-zero workloads. Beam’s repository and self-hosting guide describe running it on your own infrastructure, including Kubernetes via Helm, with the same API for managed and self-hosted deployments; a Tigris case study also describes this portability. Beam claims sub-second container launches, but the snippets do not independently validate performance or sandbox security, and other Beam pages describe sandbox launches and GPU restores in seconds. The supplied material establishes availability, but not a newly dated release or demonstrated replacement for managed platforms.

Why it matters to Scott

Beam’s documented managed/self-hosted API portability converges with Scott’s Sovereign Software Assurance position and extends his managed-only Beam.cloud serverless GPU evaluation with a concrete self-hosting option worth testing; the supplied radar pages track adjacent alternatives, not Beta9 itself. This is an evaluation opportunity rather than a dated-receipts publishing claim: the material establishes neither a newly dated release nor tested vendor-independent continuity, sandbox security, or sub-second performance.
dev:project.beamip:framework.sovereign-software-assuranceradar:sandrpod-self-hosted-e2bradar:veloxml-aws-scale-to-zeroradar:kubernetes-agent-sandbox-adoptionradar:concept.self-hosting
queries asked of Scott's wikis
  • Agent harness execution backends and self-hosted code sandboxes
  • Untrusted LLM code isolation and network access controls
  • Managed AI platform lock-in and portable infrastructure APIs
  • GPU inference cold starts and scale-to-zero economics
  • Kubernetes operations versus managed AI compute
  • AGPL infrastructure adoption and licensing constraints

Measured heat

now 0 pts/hpeak 0 pts/hcomments 0/hpeers p14momentum: steady2 platformsage 672h
points/hour across evidence · reading as of 2026-10-12 02:59:37.977291+11:00 · deterministic, not a model opinion

How the heat travelled

09-13 16:22 (minted)⭐ origin echo-reconstructedBeta9 is the open-source engine powering Beam, offering self-hosting, GPU support, scale-to-zero inference, sandboxes, background jobs, and
Beam Cloud on github (echo) · attributed from hn.story.49685152 · published time unknown
—
09-13 15:34first on hacker news · published · lag ?Show HN: OSS Modal Alternative
llom2600
—
09-13 15:34amplified on hacker news 👑hn.story.49685152
llom2600
peak 2 · 0 comments · 98% of case engagement
09-13 16:20our radar first saw it · lag ?discovery anchor: hn.story.49685152—
pace: p23 vs 1032 stories at the 336h mark (now 672h old) — ahead of aafp-commons-signed-agent-notebook (2.0x), behind agentgate-signed-agent-receipts (0.7x)

Evidence (2) — ⭐ canonical anchor

sourceobjectauthorscorecomments
🟧 hnShow HN: OSS Modal Alternative
Retrieved article excerpt

Open article · Retrieved 2026-09-13T16:22:11.502104+00:00

[Logo](https://github.com/beam-cloud/beta9/blob/main/static/beam-logo-white.png#gh-dark-mode-only)
[Logo](https://github.com/beam-cloud/beta9/blob/main/static/beam-logo-dark.png#gh-light-mode-only)

## Run AI Workloads at Scale

[Colab](https://colab.research.google.com/drive/1jSDyYY7FY3Y3jJlCzkmHlH8vTyF-TEmB?usp=sharing)
[⭐ Star the Repo](https://github.com/beam-cloud/beta9/stargazers)
[Documentation](https://docs.beam.cloud)
[Join Slack](https://join.slack.com/t/beam-cloud/shared_invite/zt-39hbkt8ty-CTVv4NsgLoYArjWaVkwcFw)
[Twitter](https://twitter.com/beam_cloud)
[AGPL](https://github.com/beam-cloud/beta9?tab=AGPL-3.0-1-ov-file)

**[Beam](https://beam.cloud?utm_source=github_readme)** is a fast, open-source runtime for serverless AI workloads. It gives you a Pythonic interface to deploy and scale AI applications with zero infrastructure overhead.

[Watch the demo](https://github.com/beam-cloud/beta9/blob/main/static/readme.gif)

## ✨ Features

- **Fast Cold Starts**: Launch containers in under a second using a custom container runtime, scheduler, and embedded caching
- **Parallelization and Concurrency**: Fan out workloads to 100s of containers
- **First-Class Developer Experience**: Hot-reloading, webhooks, and scheduled jobs
- **Scale-to-Zero**: Workloads are serverless by default
- **Volume Storage**: Mount distributed storage volumes
- **GPU Support**: Run on our cloud (4090s, H100s, and more) or bring your own GPUs

## 📦 Installation

```
pip install beam-client
```

## ⚡️ Quickstart

1. Create an account [here](https://beam.cloud?utm_source=github_readme)
2. Follow our [Getting Started Guide](https://platform.beam.cloud/onboarding?utm_source=github_readme)

## Creating a sandbox

Spin up isolated containers to run LLM-generated code:

```
from beam import Image, Sandbox


sandbox = Sandbox(image=Image()).create()
response = sandbox.process.run_code("print('I am running remotely')")

print(response.result)
```

## Deploy a serverless inference endpoint

Create an autoscaling endpoint for your custom model:

```
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}
```

## Run background tasks

Schedule resilient background tasks (or replace your Celery queue) by adding a simple decorator:

```
from beam import Image, TaskPolicy, schema, task_queue


class Input(schema.Schema):
    image_url = schema.String()


@task_queue(
    name="image-processor",
    image=Image(python_version="python3.11"),
    cpu=1,
    memory=1024,
    inputs=Input,
    task_policy=TaskPolicy(max_retries=3),
)
def my_background_task(input: Input, *, context):
    image_url = input.image_url
    print(f"Processing image: {image_url}")
    return {"image_url": image_url}


if __name__ == "__main__":
    # Invoke a background task from your app (without deploying it)
    my_background_task.put(image_url="https://example.com/image.jpg")

    # You can also deploy this behind a versioned endpoint with:
    # beam deploy app.py:my_background_task --name image-processor
```

> ## Self-Hosting vs Cloud
>
> Beta9 is the open-source engine powering [Beam](https://beam.cloud), our fully-managed cloud platform. You can self-host Beta9 for free or choose managed cloud hosting through Beam.

## 👋 Contributing

We welcome contributions big or small. These are the most helpful things for us:

- Submit a [feature request](https://github.com/beam-cloud/beta9/issues/new?assignees=&labels=&projects=&template=feature-request.md&title=) or [bug report](https://github.com/beam-cloud/beta9/issues/new?assignees=&labels=&projects=&template=bug-report.md&title=)
- Open a PR with a new feature or improvement

## ❤️ Thanks to Our Contributors
llom260020
🟧 echo.github ⭐Beta9 is the open-source engine powering Beam, offering self-hosting, GPU support, scale-to-zero inference, sandboxes, background jobs, and Beam Cloud——

Interpretation history

Decision trace