Reflection Beam on AWS SageMaker JumpStart: when self-hosting actually pencils out

A single ml.p5.48xlarge endpoint, running nothing but idle, costs $63.30 an hour on SageMaker. Leave it up for a month and the bill is north of $45,000 before a single coding agent sends it a prompt. That is the number to hold in your head before you read anything else about Reflection AI's Beam landing in Amazon SageMaker JumpStart.

AWS published the deployment guide on October 16, confirming that Beam, Reflection's 501-billion-parameter, 23-billion-active-parameter mixture-of-experts model, is now available in SageMaker JumpStart in US East (N. Virginia) and US East (Ohio). The weights, which Reflection first previewed on October 5 and released under an Apache 2.0 license, are on Hugging Face in BF16, FP8, and NVFP4 checkpoint formats. You can deploy through a managed JumpStart endpoint, through SageMaker HyperPod Inference, or by wiring up your own SGLang or vLLM runtime on HyperPod. None of that answers the question a team actually has to answer: is running this thing yourself worth it, or should you just call an API.

What Beam actually is

Beam is a sparse mixture-of-experts model built for agentic coding: resolving issues, editing code, calling tools, and chaining multi-step work over a context Reflection says runs up to 1 million tokens. Reflection trained it on 23.8 trillion tokens, then ran reinforcement learning across 10,500 Nvidia GB300 GPUs for four weeks to generate more than 100 million rollouts, according to its launch post. The pitch is efficiency, not raw top-of-leaderboard capability. Reflection's own numbers put Beam within a few points of GLM-5.2 on reasoning while claiming three to four times less inference compute to get there, a gap that widens further against 2-trillion-plus-parameter models like Qwen 3.8-Max.

Here is how Beam stacks up on three benchmarks where every model in the comparison actually reported a score, per Reflection's October 5, 2026 blog post:

Benchmark	Beam	GLM-5.2	Kimi K3	Qwen 3.8-Max
Terminal-Bench v2.1	80.1	81.0	88.3	86.6
HLE, no tools	36.2	40.5	46.9	43.6
GPQA Diamond	90.5	91.2	93.5	92.6
Source: Reflection AI, "Introducing Beam," October 5, 2026. These are Reflection's self-reported numbers; no independent lab had rerun them as of this writing.

Beam is not winning any of those three rows. Kimi K3 leads every one of them, sometimes by eight points. Reflection's actual argument is the compute-efficiency estimate from the same post: measuring FLOPs as roughly twice the active-parameter count times tokens generated, Beam's 23B active parameters do comparable reasoning work to GLM-5.2's larger active footprint for a fraction of the compute. That estimate excludes prompt prefill and serving overhead, so treat it as a compute comparison, not a measured inference cost, until someone outside Reflection reruns it.

Who this is actually for

Beam's natural buyer is a team that already needs a self-hosted or air-gapped coding model, usually for data-residency or sovereignty reasons, and is choosing among the handful of open-weight options that can plausibly run that workload. If you just want a capable coding model behind an API key, Beam is the wrong place to start looking. The interesting decision is not Beam versus Kimi K3 on a leaderboard. It's self-hosting versus calling someone else's endpoint, and that decision is almost entirely about dollars.

What it costs to run

AWS's blog recommends three instance families depending on which checkpoint you deploy. We pulled the current SageMaker on-demand hosting rates for US East (N. Virginia) straight from AWS's public pricing data:

Deployment path	Checkpoint	Instance	GPUs	On-demand rate (US East N. Virginia)
JumpStart endpoint or HyperPod + JumpStart container	FP8	ml.p5.48xlarge	8x H100	$63.296/hr
JumpStart endpoint or HyperPod + JumpStart container	FP8	ml.p5en.48xlarge	8x H200	$72.795/hr
HyperPod + custom SGLang/vLLM	NVFP4	ml.p6-b200.48xlarge	8x B200	$131.02272/hr
Source: Amazon SageMaker AI pricing, SageMaker hosting on-demand price list, fetched October 18, 2026. Instance recommendations per AWS's Reflection Beam deployment guide.

That rate, per AWS's pricing above, runs whether the endpoint is idle or saturated, and it's for one replica. Run the cheapest option, the H100 FP8 endpoint, around the clock for a month and you're at roughly $45,573. Scale to two replicas for redundancy and you've doubled it before accounting for the HyperPod cluster, EKS control plane, or S3/FSx weight caching AWS's HyperPod path assumes.

Now compare that to just calling a hosted model. Z.ai prices GLM-5.2, the model Beam is benchmarked against, at $1.40 per million input tokens and $4.40 per million output tokens per Z.ai's pricing page. Blend those evenly and you're at roughly $2.90 per million tokens processed. Divide the $45,573 monthly self-hosting cost by that blended rate and you get the volume where the two approaches cost the same: around 15.7 billion tokens a month, or roughly 524 million tokens a day, every day, continuously. That's not a hobby project's traffic. It's the kind of sustained, predictable load an enterprise coding-agent platform runs, not what a startup building an MVP sends.

Below that line, the API wins on cost every time, and it wins harder the burstier your traffic is, because the SageMaker meter runs the same rate whether the GPU sits idle or maxed out. Above it, self-hosting starts to make financial sense, and that's before you count the reasons that make it worth it regardless of the token math: weight-level control, no vendor API changes breaking your prompts overnight, and data that never leaves your VPC.

How to actually deploy it

AWS ships a sample repository with the deployment scripts, and the fastest path is the JumpStart real-time endpoint, which packages model, container, and HTTPS endpoint behind one managed workflow:

git clone https://github.com/aws-samples/sagemaker-genai-hosting-examples.git
cd sagemaker-genai-hosting-examples/01-models/ReflectionAI/Beam-1.0-501B-A23B-NVFP4/
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt

The variant-aware deploy script spins up an endpoint, sends a smoke-test request, prints the response, then tears the endpoint down, so you don't leave a billed-by-the-hour endpoint running by accident:

python jumpstart_real_time.py \
  --variant fp8 \
  --endpoint-name reflection-beam-fp8-smoke

Swap fp8 for bf16 or drop the flag entirely; NVFP4 is the script's default. If you need Kubernetes-native control over the serving runtime instead, say for a custom batching strategy or a specific SGLang build, the HyperPod path uses a separate config-driven tool:

git clone https://github.com/aws-samples/sagemaker-genai-hosting-examples.git
cd sagemaker-genai-hosting-examples/SageMakerHyperpod/reflection-beam/
cp config/deployment.env.example config/deployment.env
cp config/release.env.example config/release.env
python hyperpod_tool.py \
  --config config/deployment.env \
  --config config/release.env \
  deploy sglang \
  --timeout-seconds 1800

Swap sglang for vllm to use vLLM instead. Either way, that command needs an EKS-orchestrated HyperPod cluster with the Inference Operator already configured; this isn't a flag you flip on a cluster that doesn't exist yet. AWS's full walkthrough covers the IAM, VPC, and GPU-quota prerequisites, and they're not trivial: p5/p6 capacity is still something you request and wait on, not something you click and get.

The limits worth knowing before you commit

Region coverage is the first wall you'll hit. Beam is live in exactly two AWS regions at launch, both in the US. If your data-residency requirement is the EU, APAC, or basically anywhere that isn't US East, you're not deploying this through JumpStart today, full stop.

The second limit is operational, not contractual. Self-hosting a 501-billion-parameter MoE model means you own weight download and shard-loading time, KV-cache sizing, replica scaling, and the GPU capacity planning that goes with all of it. AWS's own guide spends an entire section on calculating memory for weights, KV cache, and runtime overhead per replica, then confirming that estimate with a load test, because getting it wrong either wastes GPU budget or throws out-of-memory errors under load. That's infrastructure work a managed API has already done for you.

And the benchmark table above is a reminder that Beam isn't the strongest open coding model you could self-host. Kimi K3 beats it on every benchmark Reflection published where both models reported a score. If raw capability matters more than inference-compute efficiency, self-hosting Beam specifically, instead of a competitor, needs its own justification.

Alternatives worth checking before you commit GPU budget

• GLM-5.2 (hosted via Z.ai, or self-hosted): the model Reflection benchmarks itself against, available today as a straightforward API call at the pricing above, no GPU procurement required.
• Kimi K3: ahead of Beam on every benchmark in the table above, per Reflection's own numbers. Worth evaluating directly if capability, not efficiency, is the deciding factor.
• DeepSeek V4.1 Flash: scored highest of any model Reflection tested on DeepSWE v1.1 (74.2 versus Beam's 44.4), per Reflection's launch post, a benchmark specifically built around resolving real GitHub issues.

The call

If your monthly agentic-coding token volume is comfortably under a few billion tokens, or your traffic is bursty rather than constant, call an API. GLM-5.2 or Kimi K3 behind a hosted endpoint will cost less than a single idle SageMaker GPU instance and you skip the IAM, VPC, and GPU-quota setup entirely.

Self-host Beam on SageMaker JumpStart when you're already past that volume, when a compliance or sovereignty requirement rules out a third-party API regardless of cost, or when you specifically need to fine-tune or inspect the weights, something no hosted API lets you do. For that buyer, the JumpStart real-time endpoint is the right starting point. Reach for HyperPod with a custom SGLang or vLLM runtime only once you know you need control the managed container doesn't give you, not before.