Reflection AI Beam on AWS: SageMaker JumpStart Setup and Cost, Specs, Benchmarks, API Pricing ($1/$3) and the Local Option

Logeshwaran
—

Reflection AI Beam is the first open-weight model from Reflection AI, the Nvidia-backed US lab: a 501-billion-parameter mixture-of-experts model that uses 23 billion parameters per token, built for coding and agent work. It was announced on October 5, 2026, and its weights went public on October 16 under the Apache 2.0 license, in BF16, FP8 and NVFP4. On AWS it is in SageMaker JumpStart (US East N. Virginia and Ohio), not in Bedrock, so you rent the whole machine: the cheapest listed instance, a p5.48xlarge, is $55.04 an hour on EC2. Two things surprise people once they look past the headlines. First, for one person the API is far cheaper than any AWS endpoint: OpenRouter charges $1 per million input tokens and $3 per million output, so one day of that p5 buys about 440 million output tokens. Second, the headlines call it America's answer to Chinese open models, but Reflection's own launch results put Beam behind Kimi K3, GLM-5.3 and DeepSeek V4.1 Flash on most of the coding tests where they share a score. What Beam sells is efficiency and a clean license. Below: every spec, what the benchmarks really say, the API routes and prices, and the AWS options from JumpStart to your own EC2 server, with real hourly costs. Running it on your own PC or Mac has its own step-by-step page: run Reflection Beam locally.

Jake saw the news on his phone during a slow afternoon at the shop: "US lab unveils open model to take on China." He had been paying for an AI subscription to write repair quotes and product listings, and "open" sounded like "free and mine." By closing time he had a plan. Download Beam, put it on the shop PC, cancel the subscription. He texted Ethan a screenshot of the headline with three fire emojis. Ethan replied with one question: "How much memory does the shop PC have?" Jake checked. Thirty-two gigabytes. "Then let's talk before you cancel anything," Ethan wrote. "Beam is real, and it might be very good. But even a heavily compressed copy needs about eight times the memory in that PC, and even the smallest download is 103 gigabytes."

⚡ Quick Answer

• What it is → a 501B-total, 23B-active open-weight model for coding and agents, text only. Full specs.

• Can you download it? → yes, since October 16, 2026, under Apache 2.0: FP8 is 468.72 GiB, NVFP4 273 GiB. What shipped.

• On AWS? → SageMaker JumpStart in us-east-1 and us-east-2, on p5, p5en or p6-b200; not Bedrock. From $55.04 an hour. AWS setup and cost.

• Is it free? → the weights are; the API costs $1 in and $3 out per million tokens on OpenRouter, and Reflection's own API is a free beta. Pricing.

• Run it locally? → not on a normal PC; the smallest file is 103 GB. The local guide.

Calling it from code? The API, OpenRouter and coding agents.

🧭 NEW HERE? READ THESE FIRST

New to open models, local AI or AWS? These five pages cover the basics this one builds on:

📌 Bookmark this; the AWS cost table and the API prices are the parts you will come back for.

What Reflection AI Beam is, in plain English

A few words do most of the work in every Beam headline, and each one is easy to misread. Here they are in plain English before we go any deeper.

  • A model is the trained AI itself: a very large file of numbers, called weights, plus the code that runs them. Chat apps and coding tools are just windows onto a model.
  • Open-weight means the company publishes those weights so anyone can download them, run them on their own hardware, and adapt them. It is not quite the same as open source: the training data and most of the training code usually stay private. Beam is open-weight: the weights went public on October 16, 2026, with a model card, serving guides and fine-tuning recipes.
  • Apache 2.0 is one of the most permissive licenses in software. In practice it means you can use the model commercially, modify it and ship products on it, as long as you keep the license and notices. That is more generous than the custom licenses on Kimi K3 and GLM-5.3.
  • Parameters are the individual numbers in the model. More parameters usually means more knowledge and skill, and always means more memory.

What "501B-A23B" means: a mixture of experts

Beam's model ID on Reflection's API is Beam-1.0-501B-A23B. The first number is the total size: 501 billion parameters. The second, after the "A," is how many are active for each word the model produces: 23 billion. That is about 4.6% of the model working at any one moment.

That gap exists because Beam is a mixture-of-experts (MoE) model. Inside, instead of one giant block that processes every word, there are many smaller "expert" blocks and a router that picks a few of them for each token. Beam uses fine-grained routed experts, which means many small experts rather than a handful of big ones.

"Think of a hospital," Ethan told Jake. "It has hundreds of doctors on the payroll, but when you walk in with a broken wrist, you only see three of them. The hospital still needs a building big enough for all of them, though."

That analogy carries the single most important fact for anyone hoping to run Beam: the 23 billion active parameters decide how fast it runs, but the 501 billion total decide how much memory it needs. All the experts have to sit in memory, because the router might call any of them for the next word. A 23B-active model does not fit where a 23B model fits. We come back to this in the hardware section.

Who is Reflection AI?

Reflection AI was founded in 2024 by two former Google DeepMind researchers, Misha Laskin and Ioannis Antonoglou, and is based in Brooklyn, New York. Its first product was Asimov, a code-comprehension agent that reads a company's source code, documents and messages to answer questions about how its software is built. Beam is its first foundation model.

The company has raised money at a remarkable pace. It came out of stealth in March 2025 with $130 million, raised $2 billion at an $8 billion valuation in October 2025 in a round led by Nvidia, and reached a valuation of about $25 billion in 2026. It has also signed large compute deals, including access to Nvidia GB300 systems at SpaceX's Colossus data center and a separate agreement with Nebius, plus a partnership to build a 250-megawatt data center in South Korea with Shinsegae, and a role as a model provider to the US Department of Energy's national laboratories. Its stated mission is to build frontier open intelligence in the United States, and Beam is the first public proof of that plan.

If you came here because you searched "does Reflection AI have a model," the answer changed on October 5: yes, and this is it. And if you are thinking of a different Reflection, the 2024 "Reflection 70B" fine-tune of Llama was an unrelated project by a different team. It has nothing to do with Reflection AI or Beam.

Reflection AI Beam specs at a glance

Everything Reflection has published about Beam so far, in one table. Two rows deserve a second look: the context window, which depends on where you read it, and the "text only" line, which matters if you hoped to send it screenshots.

SpecBeam
MakerReflection AI (Brooklyn, New York)
AnnouncedOctober 5, 2026
Model ID (API)Beam-1.0-501B-A23B (capitalization matters)
ArchitectureSparse mixture of experts, 52 layers, interleaved local and global attention
Parameters501 billion total, 23 billion active per token
Context window1 million tokens by design; 1,048,576 on OpenRouter; 262,144 in the reference vLLM setup
Max output128K tokens per response on Reflection's beta API
Knowledge cutoffJune 30, 2026
Input and outputText only; no images, audio or files
ReasoningAlways on; effort low, medium (default), high, xhigh, max
Also supportsTool calling, structured JSON outputs, streaming
Pretraining23.8 trillion tokens, under four weeks on 6,144 Nvidia GB300 GPUs
Reinforcement learning10.5K GB300 GPUs for four weeks, over 100 million rollouts, up to 256K-token rollouts
LicenseApache 2.0
WeightsReleased October 16, 2026 on Hugging Face: BF16 933.81 GiB, FP8 468.72 GiB, NVFP4 273 GiB, plus a 1.93B DFlash2 drafter
Access todayHugging Face weights; SageMaker JumpStart (us-east-1, us-east-2); Reflection API (free beta); OpenRouter ($1/$3); Ollama beam:cloud

The training story in brief

Reflection was unusually open about how Beam was made, and a few details help explain what kind of model it is. About 95% of the raw internet text it collected was thrown away during cleaning, and the company reports its quality filters kept roughly 1.8 trillion good tokens that common filters would have discarded, including most of its curated code from the web. Code and technical writing were deliberately repeated during training to deepen the model's grounding in programming. The pretraining run itself was smooth by industry standards: nine semi-automatic rewinds, and 92.3% of wall-clock time spent on training steps that made it into the final model by the end.

The reinforcement learning phase, where the model practices tasks and is rewarded for solving them, was huge: nearly one million training environments covering software engineering, terminal use, competitive coding, science, web search and tool use, with up to 170,000 sandboxes running at once and about 1.3 billion sandboxes used in total. Reflection reports capability was still climbing when the run ended. A separate safety-focused model was trained from the same base, and the two were merged through a distillation step. The safety evaluation results have not been published yet; Reflection plans to publish them with the technical report.

One training detail shapes how Beam feels to use: Reflection trained it with a length penalty that rewards correct answers reached with fewer tokens. That is where the reasoning-effort setting comes from. At low, Beam thinks briefly and answers fast. At max, it is allowed to think for a long time on hard problems. Because reasoning is mandatory, even low spends some tokens thinking.

Beam benchmarks: what the launch chart really shows

Reflection published a detailed chart comparing Beam with seven other models. It deserves credit for including models that beat Beam, and for marking missing scores as "not reported" instead of hiding them. Here are the rows that matter most, copied from that chart. Higher is better on every row, and "NR" means not reported.

BenchmarkBeamGLM 5.2GLM 5.3Kimi K3Qwen 3.8 MaxDeepSeek V4.1 Flash
Terminal Bench v2.180.181.088.288.386.690.6
SWE Bench Pro v2-Hard77.2NR84.388.2NRNR
SWE Bench Pro v165.562.1NRNR67.7NR
DeepSWE v1.144.444.061.068.051.074.2
SWE Atlas Codebase QnA34.6NR61.068.0NRNR
AIME 2026 (math)97.899.2NRNRNRNR
HLE, no tools36.240.542.346.943.639.1
GPQA Diamond (science)90.591.291.793.592.690.9
MCP Atlas (tool use)78.777.884.282.384.5NR
AutomationBench public37.026.248.246.739.854.8
IFBench (following instructions)79.773.3NRNR82.8NR
AA-LCR (long context)79.378.379.788.780.384.0

Read across the rows and a clear picture forms.

  • Against GLM-5.2, Beam is roughly even. It wins on SWE Bench Pro v1, DeepSWE (barely), MCP Atlas, AutomationBench, instruction following and long context. It loses on Terminal Bench (by less than a point), math, HLE and GPQA. That matches Reflection's own claim: "competitive with larger open models like GLM 5.2."
  • Against Kimi K3, GLM-5.3 and DeepSeek V4.1 Flash, Beam trails on almost every shared row. The gaps are not small on some coding tests: 34.6 against 61.0 and 68.0 on codebase questions, 44.4 against 74.2 on DeepSWE. Reflection admits as much: "frontier open models like Kimi K3 remain ahead on raw capability."
  • Against the other Western open models, Beam leads. The chart also includes Inkling and Nvidia's Nemotron 3 Ultra, and Beam beats both on nearly every row they share, for example 80.9 against 77.6 and 70.7 on SWE Bench Verified, and 80.1 against 63.8 and 56.4 on Terminal Bench. That is the honest version of "America's best chance": the strongest Western open-weight model in this chart, not the strongest open model overall.

The DeepSeek comparison is the most telling. DeepSeek V4.1 Flash activates only 8 to 16 billion parameters per token by its own model card, fewer than Beam's 23 billion, and its API costs $0.15 per million input tokens off-peak. In this chart it scores higher than Beam on every coding row where both have a number. Beam's efficiency story is real against GLM-5.2, but it is not unique.

The "3 to 4 times less compute" claim, explained

Reflection's headline efficiency number says Beam reaches GLM-5.2-level scores on advanced reasoning tests "while using 3–4× less inference compute." The method behind it is simple, and worth understanding before you repeat it. Reflection estimated compute as 2 × active parameters × the average number of tokens generated per attempt. Two things push that number down for Beam: fewer active parameters than GLM-5.2, and shorter answers, thanks to the length penalty in training.

Reflection is also upfront about what the estimate leaves out: reading the prompt (prefill), attention costs that grow with context length, and real serving overhead. So it is a fair comparison of how much "thinking" each model does per answer, not a measured bill. A real cost comparison needs real prices, and Beam does not have a public price yet.

"So it's a fuel-economy sticker," Jake said, "not a receipt."

"Exactly," Ethan said. "A useful sticker. But you only know your real cost when you've driven it on your own roads."

Every number here is still Reflection's own

The weights are out, so outside researchers can finally test Beam themselves, and independent leaderboards usually post results within days of a release. Until they do, the numbers are Reflection's. Benchmarks from a model's maker are not worthless, and Reflection's are more honest than most because they show their losses, but they are always run under the maker's best settings. Treat the chart as a starting point, and wait for independent runs before you bet a product on Beam.

The scores published with the weights

The October 16 model card adds full-precision (BF16) scores on a different set of tests from the launch chart:

BenchmarkWhat it measuresBeam (BF16)
SWE-bench VerifiedFixing real GitHub issues in Python projects81.6%
SWE-bench Pro v1Harder, multi-language software tasks66.1%
Terminal Bench v2.1Getting work done in a real terminal80.1%
AIME 2026Competition math97.7%
GPQA DiamondGraduate-level science questions90.6%
LongBench v2Reasoning over very long documents67.5%

Alongside them, Reflection repeats its central claim: comparable quality to leading open models with about three times fewer reasoning tokens. That is the claim to test on your own work, because tokens are what you pay for.

Reflection did share a few demos alongside the chart. Beam built a live New York City subway map from public transit data, a 3D browser game, and a fine-tuning notebook for Google's smallest Gemma 4 model that improved its held-out accuracy by 66.5%. On a viral "is this point land or water" grid puzzle, Beam got 95.5% coverage, which Reflection places between Opus 5 (92.5%) and Fable 5 (97.8%). Demos show what is possible on a good day; the chart shows the average day.

How to use Reflection AI Beam today: the API, OpenRouter and coding agents

Now that the weights are out, there are several ways to call Beam without running it yourself: Reflection's own API (a free beta), OpenRouter ($1 in, $3 out per million tokens, model reflection/beam-1.0-501b-a23b), and Ollama's hosted beam:cloud tag. Reflection's API is the one with every feature described below. Here is the whole path, from sign-up to a first answer.

  1. Sign up at platform.reflection.ai. The API runs as a free beta, and access can still be rolled out in stages; if your account is not enabled yet, OpenRouter works today with the same OpenAI-style code. API keys become available once your account is enabled.
  2. Create a project and an API key. In the platform, open API Keys, pick a project, and create a key. Copy it straight away; the full key is shown only once. Keys belong to both a project and the person who made them, and a key stops working if its creator leaves the organization.
  3. Add a payment method if asked. Some organizations must verify a credit card in Billing before keys work. If your first request returns 403 payment_method_required, that is the step you skipped.
  4. Save the key as an environment variable called REFLECTION_API_KEY, never in your code or a public repository.
  5. Send your first request to the OpenAI-compatible endpoint, shown below.

A first request with curl, which works in Windows Terminal, macOS Terminal and Kali alike:

curl https://api.reflection.ai/openai/v1/chat/completions \
  -H "Authorization: Bearer $REFLECTION_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Beam-1.0-501B-A23B",
    "reasoning_effort": "low",
    "max_completion_tokens": 4000,
    "messages": [
      {"role": "user", "content": "Write a two-sentence repair quote for a cracked phone screen."}
    ]
  }'

And the same thing in Python, using the official OpenAI library pointed at Reflection:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.reflection.ai/openai/v1",
    api_key=os.environ["REFLECTION_API_KEY"],
)

reply = client.chat.completions.create(
    model="Beam-1.0-501B-A23B",
    reasoning_effort="medium",
    max_completion_tokens=8000,
    messages=[{"role": "user", "content": "Explain RAID 1 to a shop owner in three sentences."}],
)
print(reply.choices[0].message.content)

Jake's first test was exactly that kind of everyday job, a repair quote, and Beam handled it in seconds at low effort. The model is built for much harder work than that, but small tasks are the right way to learn its habits before you trust it with anything bigger.

Reasoning effort: the setting that controls cost and speed

Beam always reasons before it answers, and you choose how much with reasoning_effort. The accepted values are low, medium, high, xhigh and max. If you leave it out, Beam uses medium. The OpenAI values none and minimal are rejected with a 400 unsupported_value error, because there is no way to switch Beam's thinking off.

Two practical consequences follow. First, reasoning tokens are billed and rate-limited like any other output, and they count toward max_completion_tokens. Second, if you set that limit too low, Beam can spend the whole budget thinking and return finish_reason: "length" with an empty answer. When that happens, raise the limit or lower the effort. Start at medium, drop to low for simple, latency-sensitive jobs, and go up only when answers are not good enough.

The model's thinking comes back separately, in a field called reasoning_content, while the answer stays in content. Show users the answer, not the reasoning. When you build tool-calling loops, send the assistant's message back unchanged, including its reasoning_content, so the model keeps its train of thought.

What works, what doesn't: the OpenAI-compatibility gotchas

Reflection's endpoint copies OpenAI's Chat Completions format, so most OpenAI-based code works after changing the base URL and key. "Most" is doing some work, though. These are the differences most likely to bite:

  • Only Chat Completions and Models exist. The Responses, Embeddings, Images, Audio, Files, Batch and Assistants endpoints are not supported. A tool built on the newer Responses API will not work with Beam.
  • stop sequences are accepted but ignored. Generation does not stop at them. If your code relies on stop strings to cut output, trim the text yourself. This one fails silently, so it is worth knowing before you debug for an hour.
  • Text only. Image, audio and file inputs are rejected.
  • Some parameters are fixed: n must be 1, logprobs must be false, store must be false (completions are not stored), and logit_bias must be empty.
  • Unknown parameters fail loudly. Fields such as user, metadata, top_logprobs or prediction return 400 unsupported_parameter. If a framework sends one by default, turn it off in that framework's settings.

The good news is the list of things that do work: system and developer messages, streaming with usage reports, tool calling with tool_choice and parallel calls, and structured JSON outputs with or without a schema.

Use Beam inside a coding agent: Mirror CLI, OpenCode, Pi and Hermes

Beam was trained for agentic coding, so most early users will meet it inside a coding agent rather than a chat box. There are four routes:

  • Mirror CLI is Reflection's own terminal coding agent, in early beta. It uses Beam by default, so setup is mostly pasting your API key. If you have used Mirror with another provider, start it with mirror --api reflection --model Beam-1.0-501B-A23B, and set effort with --reasoning-effort high or the /reasoning command.
  • OpenCode works through a custom provider entry in its config file. Give the model a context limit of 262,144 and an output limit of 131,072; without the limit, OpenCode never compacts a long session. Its effort picker offers low, medium and high, and you add xhigh and max as variants.
  • Pi works the same way, with its thinking levels mapped to Beam's five effort levels.
  • Hermes works too, with one known quirk: its automatic session-title request asks for no reasoning, Beam refuses, and a one-shot run can exit with "Auxiliary title generation failed: Connection error." It is harmless.

Two habits save trouble in every agent. Check that the model ID is exactly Beam-1.0-501B-A23B, capital letters included, and remember that an agent fires many requests per task, all counted against your organization's rate limits.

Rate limits and the daily allowance

Beta limits apply to your whole organization, shared across every project and key, so creating more keys does not raise them. Limits are counted in requests and tokens, per minute and per UTC day, and there is also a cap on how many requests can be in progress at once. Your plan may add a daily token allowance. Daily limits reset at 00:00 UTC, which is 5:30 in the morning in India and evening in the Americas.

When you hit a limit, the API returns 429 with a Retry-After header. If the daily allowance is spent, it also sends x-should-retry: false, and retrying is pointless until the reset. Response headers such as x-ratelimit-remaining-tokens show how close you are. Reflection promises details on requesting higher limits soon.

Is Reflection AI Beam free? Pricing for the weights, the API and AWS

There are three answers, because Beam now exists in three forms.

The weights are free. Since October 16, 2026, anyone can download Beam from Hugging Face under Apache 2.0, run it, fine-tune it and build commercial products on it without paying Reflection anything. "Free" stops at the download button, though: running a 501-billion-parameter model costs real money in hardware or cloud time, as the AWS section shows.

The API has prices now. OpenRouter serves Beam as reflection/beam-1.0-501b-a23b at $1.00 per million input tokens and $3.00 per million output tokens, with a 1,048,576-token context. Reflection's own API at platform.reflection.ai runs as a free beta with per-account limits, and the Ollama library carries a hosted beam:cloud tag that bills against your Ollama account.

AWS bills by the hour. There is no pay-per-token Beam on AWS yet; SageMaker JumpStart and EC2 both charge for the instance whether it is busy or idle.

For context, here is what the rival models cost on their makers' own APIs, per million tokens, as listed in early October:

ModelInputOutput
Reflection Beam (OpenRouter)$1.00$3.00
GLM-5.2 and GLM-5.3 (Z.ai)$1.40 ($0.26 cached)$4.40
Kimi K3 (Moonshot)$3.00 ($0.30 cached)$15.00
DeepSeek V4.1 Flash$0.15 off-peak, $0.30 peak$0.60 off-peak, $1.20 peak

So Beam lands below GLM-5.3 and far below Kimi K3, and well above DeepSeek V4.1 Flash. Beam's pitch is that it needs about a third of the reasoning tokens of comparable open models for the same quality, which, if it holds on your work, makes the $3 output price go further than the number suggests. Measure it on a day of your own prompts before you decide.

"So I keep my subscription for now," Jake said.

"Run a week of your repair quotes through the API first," Ethan said. "At these prices that costs less than a coffee, and then you are comparing your bill, not a headline."

Can you run Reflection AI Beam locally? The short answer

Yes, now that the weights are out, but only on very large machines. llama.cpp added the Beam architecture in release b11701 on October 16, and Unsloth published GGUF files the same day. The rule is that the whole file has to fit in your RAM plus VRAM:

FileSizeWhat it runs on
UD-IQ1_S (1-bit GGUF)103 GBa 128 GB desktop with a 24 GB graphics card, slowly
UD-Q2_K_XL (2-bit GGUF)187 GBa 256 GB workstation
UD-Q4_K_XL (4-bit GGUF, recommended)307 GBa 512 GB Mac Studio
NVFP4 (official)273 GiBfour NVIDIA B300s (the reference setup), or Blackwell servers
FP8 (official)468.72 GiBan eight-GPU H100 or H200 server
BF16 (official)933.81 GiBdata-center hardware only

A normal 16 to 64 GB laptop cannot run Beam in any form. One trap to know about: ollama run beam runs Ollama's hosted beam:cloud copy, not a local one. The Windows 11, Mac and Kali Linux commands, the memory math for every file, and the fixes for day-one errors are in our dedicated guide: Run Reflection Beam locally. This page stays with the cloud side.

How to run Reflection AI Beam on AWS: SageMaker JumpStart and EC2

For most companies, "self-hosting" Beam means renting GPUs in the cloud rather than buying a server. On AWS there are now two real routes and one that does not exist yet: SageMaker JumpStart (managed endpoint, launched October 16), your own EC2 server with vLLM, and Amazon Bedrock (not available).

Is Beam on Amazon Bedrock?

No, not as of October 17, 2026. Bedrock is AWS's service for calling ready-made models per token, without managing any servers, and Beam is not in its catalog. AWS put Beam in SageMaker JumpStart instead. If Beam reaches Bedrock later, that will be the easiest route by far.

You also cannot bring Beam into Bedrock yourself. Bedrock's Custom Model Import feature, which lets you upload your own open-weight model, has three rules Beam breaks:

  • It accepts only listed architectures: Llama, Mistral, Mixtral, Flan, GPTBigCode, Qwen and GPT-OSS families. Beam's architecture is not on the list.
  • Text models must have weights under 200 GB. Beam's smallest official checkpoint, NVFP4, is 273 GiB; FP8 is 468.72 GiB.
  • The model's maximum context length must be under 128K. Beam's is 1 million tokens by design, and the reference vLLM setup serves 262,144.

Route 1: SageMaker JumpStart, the managed endpoint

JumpStart is SageMaker's model catalog: you pick a model, choose an instance, and AWS deploys it to an HTTPS endpoint with its own serving container. Beam is listed in US East (N. Virginia) and US East (Ohio), in two precisions:

PrecisionSageMaker instanceGPUsEC2 on-demand floor (us-east-1)Per 24 hours
FP8ml.p5.48xlarge8 × H100$55.04/hour$1,320.96
FP8ml.p5e.48xlarge / ml.p5en.48xlarge8 × H200p5en: $63.30/hour$1,519.10
NVFP4ml.p6-b200.48xlarge8 × B200$113.93/hour$2,734.39

The price column is the EC2 rate for the same instance. A SageMaker endpoint charges its own ml. rate, which runs above it, so treat these numbers as the floor and check the SageMaker pricing page for your Region before you commit. If SageMaker is new to you, our plain-English SageMaker guide explains endpoints.

The quickest deployment is AWS's sample repository, which wraps JumpStart in one script:

  1. Request the quota first. New accounts usually have zero quota for these endpoint instances. In Service Quotas, under Amazon SageMaker, request "ml.p5.48xlarge for endpoint usage" in us-east-1. Without it, the deploy fails with ResourceLimitExceeded; our ResourceLimitExceeded guide walks through the request.
  2. Clone the samples and deploy the FP8 variant:
    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/
    python jumpstart_real_time.py --variant fp8 --endpoint-name reflection-beam-fp8-smoke
  3. Test it with one short request from the notebook or the SageMaker runtime API before you point anything real at it.
  4. Delete the endpoint the moment you finish. An idle endpoint bills exactly like a busy one:
    aws sagemaker delete-endpoint --endpoint-name reflection-beam-fp8-smoke --region us-east-1

The same folder has scripts for SageMaker HyperPod clusters, with an option to serve through SGLang or vLLM instead of the JumpStart container, for teams that already run HyperPod.

Route 2: your own EC2 server with vLLM

Plain EC2 is cheaper than a SageMaker endpoint for the same GPUs and gives you full control. The instance has to hold the weights in GPU memory with room left for context. These are the GPU instances that can, with on-demand Linux prices in US East (N. Virginia); the monthly column assumes the instance runs around the clock (730 hours):

InstanceGPUsGPU memoryBeam fits atPer hourPer month, 24/7
g7e.24xlarge4× RTX PRO 6000 Blackwell384 GiBNVFP4 (273 GiB) or 4-bit GGUF$16.57about $12,100
g6e.48xlarge8× L40S384 GiBNVFP4 (273 GiB) or 4-bit GGUF$30.13about $22,000
g7e.48xlarge8× RTX PRO 6000 Blackwell768 GiBFP8 (468.72 GiB), with room$33.14about $24,200
p5.48xlarge8× H100640 GiBFP8$55.04about $40,200
p5en.48xlarge8× H2001,128 GiBFP8 roomy, BF16 tight$63.30about $46,200
p6-b200.48xlarge8× B2001,440 GiBBF16$113.93about $83,200

Some quick reading of that table, now that the real file sizes are known:

  • g7e.24xlarge (384 GiB) holds the official NVFP4 checkpoint (273 GiB) with about 110 GiB to spare for context, at about $16.57 an hour, roughly $133 for an eight-hour working day. Its RTX PRO 6000 Blackwell GPUs support the FP4 format, but neither Reflection nor AWS offers it as a supported setup, so treat it as an experiment.
  • g7e.48xlarge is the value pick for FP8. At about $33 an hour it holds the FP8 weights (468.72 GiB) with roughly 300 GiB to spare. The H100s in p5.48xlarge have much faster memory and interconnects, which matters when many users share one server, and p5 is the instance JumpStart uses for FP8.
  • Full precision needs P5en or P6. Unless you are fine-tuning or doing research that needs the BF16 weights (933.81 GiB), FP8 or NVFP4 is the serving format.
  • Running 24/7 is expensive. Even the smallest option is about $12,000 a month if left on. Self-hosting pays off for constant, heavy use, or when data must stay in your own AWS account; for occasional use, the API is almost always cheaper.

Prices differ by Region, and Savings Plans or Reserved Instances lower them for long commitments. Our Reserved vs Savings Plans vs Spot decision tree walks through which discount fits which pattern.

Step by step: launching Beam on EC2

  1. Request GPU quota first. New and small AWS accounts usually have little or no quota for large GPU instances. In the Service Quotas console, find Running On-Demand G and VT instances (for g7e and g6e) or Running On-Demand P instances (for p5 and p6). Quotas are counted in vCPUs: g7e.24xlarge needs 96, and the 48xlarge sizes need 192. Our guide to the vCPU quota exceeded error covers how to word the request.
  2. Plan for capacity. Even with quota, big GPUs can be sold out in a Region, which shows up as InsufficientInstanceCapacity. Try another Availability Zone or Region, or reserve time ahead with EC2 Capacity Blocks for ML.
  3. Launch the instance with an AWS Deep Learning AMI for Ubuntu, which comes with the NVIDIA driver, CUDA and Docker. Put it in a private subnet if you can.
  4. Give it storage. Attach a gp3 EBS volume of about 1 TB for FP8 or NVFP4 (2 TB if you also want BF16). At $0.08 per GB-month in US East, 1 TB of gp3 is about $80 a month, and downloading into EC2 from the internet has no data-transfer charge.
  5. Download the weights with the Hugging Face command-line tool:
    pip install -U huggingface_hub
    export MODEL_DIR=/data/beam
    hf download reflection/Beam-1.0-501B-A23B-FP8 --local-dir "$MODEL_DIR/fp8"
    # on Blackwell GPUs:  hf download reflection/Beam-1.0-501B-A23B-NVFP4 --local-dir "$MODEL_DIR/nvfp4"
    # optional drafter:   hf download reflection/Beam-1.0-501B-A23B-DFlash2 --local-dir "$MODEL_DIR/dflash2"
  6. Serve it with vLLM's Beam image, spread across all eight GPUs with tensor parallelism. The Beam tool-call and reasoning parsers are what make agents work:
    docker run --rm --init --name beam --gpus all --shm-size=32g \
      -p 127.0.0.1:8000:8000 \
      --mount "type=bind,src=$MODEL_DIR,dst=/weights,readonly" \
      -e HF_HUB_OFFLINE=1 --entrypoint vllm vllm/vllm-openai:reflection-beam \
      serve /weights/fp8 --served-model-name Beam-1.0-501B-A23B \
      --tensor-parallel-size 8 --max-model-len 131072 \
      --enable-prefix-caching --enable-auto-tool-choice \
      --tool-call-parser beam --reasoning-parser beam
    Reflection's reference setup is the NVFP4 build on four B300 GPUs with --tensor-parallel-size 4, --max-model-len 262144 and the DFlash2 drafter, which Reflection reports speeds a single user up 2.3x to 3.0x. Start with a shorter --max-model-len and raise it once the model loads; context is what eats the spare memory.
  7. Keep it private. Leave port 8000 closed to the internet and reach it through an SSH tunnel or AWS Systems Manager port forwarding:
    aws ssm start-session --target <your-instance-id> \
      --document-name AWS-StartPortForwardingSession \
      --parameters '{"portNumber":["8000"],"localPortNumber":["8000"]}'
    Then point any OpenAI-compatible tool at http://localhost:8000/v1. Our Systems Manager explainer covers the setup.
  8. Stop it when you are done. A stopped instance does not bill for compute, but its EBS volume still costs storage. Set a budget alert before you start; a forgotten p5 burns about $1,320 a day. Our three-layer billing alert setup takes ten minutes.

Spot Instances look tempting at a fraction of the price, but GPU Spot capacity is scarce, and AWS can take the instance back with a two-minute warning. They are fine for experiments and a poor fit for anything users depend on.

API or AWS? The break-even, now that both numbers exist

One day of the cheapest listed machine, a p5.48xlarge at $1,320.96, buys about 440 million output tokens on OpenRouter at $3 per million. A busy developer running a coding agent all day uses a few million. So:

  • Use the API if your usage is occasional or bursty, you want to try Beam without commitment, or nobody on your team runs GPU servers.
  • Self-host on AWS if your data must stay inside your own AWS account, you need to fine-tune Beam on your own code or documents, or a team will keep the endpoint busy most of the day.
  • Do the math with your own traffic: take the instance's daily cost, divide it by the tokens your workload actually pushes through it in a day, and compare with $1 in and $3 out per million.

Beam vs Kimi K3 vs GLM-5.3 vs DeepSeek V4.1 Flash

Beam enters a crowded field of big open-weight models, and most of the strongest ones come from Chinese labs. Here is how they line up on the things that decide what you can actually do with them.

ModelMakerSize (total / active)LicenseDownload today?Images?
BeamReflection AI (US)501B / 23BApache 2.0Yes, since October 16No, text only
Kimi K3Moonshot AI (China)2.8T / 104BCustom Kimi K3 licenseYesYes, and video
GLM-5.3Z.ai (China)about 753B totalCustom GLM-5.3 licenseYesNo
GLM-5.2Z.ai (China)about 753B totalMITYesNo
DeepSeek V4.1 FlashDeepSeek (China)552B backbone / 8B to 16BMITYesNo

What that means in practice:

  • For raw capability today, Kimi K3 leads on Reflection's own results, but at 2.8 trillion parameters it is a data-center model, and its API is the most expensive of the group.
  • For cheap, strong coding today, DeepSeek V4.1 Flash beats Beam on Reflection's coding rows and costs cents per million tokens. Its weights are available under MIT.
  • For a permissive license and a Western supply chain, Beam is the one to watch. Apache 2.0 from a US lab matters to companies and governments whose policies rule out Chinese-origin models, and the smaller total size makes it cheaper to host than GLM-5.3 or Kimi K3.
  • For self-hosting cost, Beam should win among models of its tier: about two-thirds the total size of GLM-5.3, and a fifth of Kimi K3.

Reflection AI vs DeepSeek

The comparison everyone is making. DeepSeek is the Chinese lab whose efficient open models shook the industry, and Reflection's founders have openly framed their company as building a Western answer. On today's evidence, DeepSeek V4.1 Flash is stronger at coding, cheaper to call and already downloadable. Beam's advantages are its Apache 2.0 license, its US origin, and its strength in tool use and instruction following against GLM-5.2. Neither choice is wrong; they solve different problems.

Reflection AI vs Anthropic, OpenAI and Cursor

People search these pairings, so here is the plain difference. Anthropic and OpenAI build closed frontier models that you use only through their apps and APIs; you never get the weights. Reflection is betting on the opposite approach: give the weights away and compete on openness and efficiency. On capability, Reflection's own demos compare Beam with Anthropic's Opus 5 and Fable 5 on a single puzzle, which is not a general ranking. Cursor is a code editor with built-in AI, not a model maker in the same sense, so the realistic relationship is that Beam could one day power tools like it. Today, Beam runs in Reflection's Mirror CLI and in open agents such as OpenCode.

Update, October 6, 2026: If you want one of the open models in Beam's comparison chart running on AWS today, without waiting for weights or renting GPUs, GLM-5.3 joined Amazon Bedrock as a managed model on October 5. It costs $1.68 per million input tokens and $5.28 per million output tokens with global routing and keeps its 1-million-token context, but for now it is limited to eligible enterprise accounts. Our guide to GLM 5.3 on Amazon Bedrock has the model IDs, the full price table, working code and what to use if your account is not on the list.

Update, October 6, 2026: Beam is not the only big open-weight model with a release date this month. Mistral launched Mistral Large 4, nicknamed le Chonk, as an API preview today, with 1.05 trillion total and 49 billion active parameters, image input and a 1-million-token context, and promised the weights by the end of October. You can call it now for $0.68 per million input tokens and $2.09 per million output tokens. Our Mistral Large 4 guide covers the price, the API and what running it at home would take.

What shipped on October 16, and what to watch next

Reflection released the weights on October 16, eleven days after the announcement. Here is how the checklist from launch week came out:

  • The license: plain Apache 2.0 on Hugging Face for the weights.
  • The file formats: official BF16 (933.81 GiB), FP8 (468.72 GiB) and NVFP4 (273 GiB) checkpoints, plus a 1.93-billion-parameter DFlash2 drafter for speculative decoding.
  • Serving instructions: recipes for vLLM, SGLang and TokenSpeed, with four NVIDIA B300 GPUs as the reference setup.
  • Safety numbers: the model card reports an 88.9% refusal rate on harmful requests and 81.5% compliance on harmless ones.
  • The API price: $1 in and $3 out per million tokens on OpenRouter; Reflection's own API is a free beta.
  • Distribution partners: more than 40, including AWS (SageMaker JumpStart and Trainium), Google Cloud, Ollama (as a hosted cloud tag), OpenRouter, Together, Fireworks and LM Studio; Azure and Oracle are listed as coming soon.
  • llama.cpp and GGUF: llama.cpp release b11701 added the architecture the same day, and Unsloth published GGUF files from 103 GB.

Still worth watching: independent leaderboards (the efficiency claim checked by someone other than its maker), whether Beam reaches Amazon Bedrock as a per-token model, and an MLX build for Macs. We will add a dated note here when any of those land.

Who should care about Beam, and who can skip it

Watch it closely if you:

  • run AI coding agents and want an open model you can host yourself under a permissive license;
  • work somewhere that cannot use Chinese-origin models but needs open weights for privacy, sovereignty or fine-tuning;
  • pay for large volumes of agent tokens and care about cost per finished task more than peak benchmark scores;
  • build on AWS and want a model that fits on a single 8-GPU instance at FP8.

You can safely skip it, for now, if you:

  • want a model to run on your own laptop or gaming PC; Beam will never fit there, and smaller open models are the answer;
  • need image or document understanding; Beam is text only;
  • are happy with a subscription chatbot for everyday writing; nothing about Beam changes that this month.

Jake landed in the second group, and was relieved to. His real need, faster quotes and listings, was already met. What he took away was a better question to ask about every future headline: "Can I actually download it, and what would it run on?"

Honest limitations, as of October 17

  • Benchmarks are still self-reported. The weights are out, so independent testing can start, but the published numbers are Reflection's.
  • Huge to self-host. The smallest official checkpoint is 273 GiB; the smallest community file is 103 GB. There is no small Beam.
  • No per-token AWS option. On AWS it is hourly instances only, from $55.04 an hour for the cheapest listed machine.
  • Text only. No vision, audio or file input.
  • Context depends on where you run it. 1 million tokens by design, 1,048,576 on OpenRouter, 262,144 in the reference vLLM setup.
  • Behind the top Chinese open models on most coding and reasoning rows in its own launch chart.
  • Beta API behavior can change, including limits and endpoints.

None of that makes Beam a disappointment. It is a version one that shipped on time, from a lab that published its losses next to its wins, under one of the most permissive licenses in software. That is a better start than most.

Troubleshooting the Reflection API

The errors early users are most likely to hit, and what each one means:

You seeWhat it meansFix
401 invalid_api_keyKey is incomplete, revoked, or its creator left the organizationCreate a new key and copy it in full
401 invalid_authorization_headerHeader is not in the right formSend Authorization: Bearer <key>
403 payment_method_requiredOrganization needs a verified cardAdd one in Billing on the platform
409 billing_setup_required or tier_switch_pendingBilling is incomplete or changing tierFinish setup, or wait for Retry-After
400 unsupported_value on reasoning_effortYou sent none or minimalUse low through max
400 unsupported_parameterA framework sent user, metadata or similarTurn that option off in the framework
400 context_length_exceededPrompt plus output budget is over the limit; nothing is truncated for youShorten history or lower max_completion_tokens
Empty answer, finish_reason: "length"Beam used the whole budget reasoningRaise max_completion_tokens or lower the effort
Output runs past your stop stringstop is accepted but ignoredTrim the text in your own code
415Body sent without a JSON content typeAdd Content-Type: application/json
429 rate_limit_exceededA per-minute or daily limit was hitWait for Retry-After; if x-should-retry: false, wait for 00:00 UTC
503 inference_capacity_unavailableReflection's servers are temporarily fullRetry after Retry-After
"Model not found"Wrong model ID or capitalizationUse exactly Beam-1.0-501B-A23B

Every response carries an x-request-id header. Log it; it is the first thing support will ask for.

For IT admins and engineering leads

If your team wants to trial Beam, a little setup now saves an awkward conversation later.

  • Know where the data goes. On the API, prompts and code go to Reflection's servers. Reflection's endpoint does not store completions (store is fixed to false), but review its terms and privacy policy before sending customer data or proprietary source code.
  • Use one project per application and environment. Keys are scoped to a project, which keeps usage and revocation clean. Remember that rate limits are shared across the whole organization, so one runaway agent can starve every other project.
  • Keys belong to people. A key dies when its creator leaves the organization. For production, create keys from a service owner's account and document who that is.
  • Plan the self-hosted path early if your policies require data to stay in your own cloud account. Request GPU quota now, pick a Region with g7e or p5 capacity, and set budget alerts before anyone launches an instance.
  • Pilot with a share of traffic. A new model with self-reported benchmarks belongs on a slice of non-critical work first, with results compared against your current model on your own tasks.
  • Watch the license on release day. Apache 2.0 is easy for legal teams to approve; confirm that is exactly what ships.

Reflection AI the company: stock, valuation and investment questions

A surprising number of people searching for Beam are really asking about the company. The plain facts:

  • Reflection AI is private. It is not listed on any stock exchange, so there is no Reflection AI stock or ticker to buy, and it has not announced plans to go public.
  • Its investors include Nvidia, which led the October 2025 round of $2 billion at an $8 billion valuation, along with firms such as Sequoia Capital and Lightspeed Venture Partners. Its 2026 funding valued it at about $25 billion.
  • Ordinary investors cannot buy in directly. Private-company shares sometimes trade on secondary marketplaces for accredited investors, but that is a niche, risky route, and nothing here is investment advice.
  • How it plans to make money: its API platform, its enterprise and sovereign offerings, and products such as Asimov and Mirror. Giving away weights while selling hosting, support and tools is a common open-model business, but Reflection has not published revenue figures.
  • Is it legit? Yes. It is a well-funded lab founded by senior former DeepMind researchers, with public deals and a real model. Whether Beam is good enough for you is a separate question, and the rest of this page is about that.

Reflection AI Beam: frequently asked questions

What is Reflection AI Beam?

Beam is Reflection AI's first open-weight model, announced October 5, 2026, with weights released October 16 under Apache 2.0. It is a mixture-of-experts model with 501 billion total and 23 billion active parameters, built for coding, reasoning and agent work.

Is Reflection AI Beam open source?

It is open-weight under Apache 2.0, which allows commercial use and modification, and the weights have been public on Hugging Face since October 16, 2026. The training data and most training code stay private, so "open-weight" is the precise term.

When will the Beam weights be released?

They were released on October 16, 2026, on Hugging Face, in BF16 (933.81 GiB), FP8 (468.72 GiB) and NVFP4 (273 GiB), with a DFlash2 drafter for faster generation.

Is Reflection AI free?

The weights are free to download and use under Apache 2.0. Reflection's own API is a free beta with account limits; OpenRouter charges $1 per million input tokens and $3 per million output. Running the weights yourself costs money in hardware or cloud GPUs.

How much does the Reflection AI API cost?

On OpenRouter, Beam costs $1.00 per million input tokens and $3.00 per million output tokens, with a 1,048,576-token context. Reflection's own API at platform.reflection.ai is a free beta.

Can I run Reflection AI Beam locally?

Only on very large machines. llama.cpp b11701 or newer runs Unsloth's GGUF files, from 103 GB (1-bit, for a 128 GB desktop with a 24 GB card) to 307 GB (4-bit, for a 512 GB Mac Studio). Our separate local guide has the commands.

How much RAM do I need to run Beam?

About as much as the file you choose, plus room for context: 103 GB for the smallest GGUF, 307 GB for the recommended 4-bit GGUF, 273 GiB for the official NVFP4 checkpoint and 468.72 GiB for FP8.

Can I run Beam on AWS?

Yes. Beam is in SageMaker JumpStart in US East (N. Virginia) and US East (Ohio), on ml.p5.48xlarge or ml.p5en.48xlarge for FP8 and ml.p6-b200.48xlarge for NVFP4. You can also run it on your own EC2 GPU instance with vLLM.

Is Reflection Beam available on Amazon Bedrock?

Not as of October 17, 2026; AWS offers it through SageMaker JumpStart instead. Bedrock Custom Model Import cannot take it either, because Beam's architecture is not supported, its checkpoints exceed the 200 GB limit for text models, and its context is over the 128K limit.

What does 501B-A23B mean?

501 billion total parameters, with 23 billion active for each token. The active count sets the speed; the total count sets the memory you need.

How does Beam compare to Kimi K3?

Kimi K3 scores higher on almost every shared row of Reflection's results, handles images and video, and is downloadable today, but it has 2.8 trillion parameters. Beam is much smaller, cheaper to host, and promises a more permissive license.

Is Beam better than DeepSeek?

Not at coding, by Reflection's own results: DeepSeek V4.1 Flash scores higher on every shared coding row and costs $0.15 per million input tokens off-peak. Beam's edges are the Apache 2.0 license and its US origin.

Does Beam support images?

No. Beam is text only. The API rejects image, audio and file inputs, though Beam can work with information from other formats once it is turned into text.

What is Beam's context window?

1 million tokens by design. OpenRouter serves 1,048,576 tokens, and Reflection's reference vLLM setup serves 262,144 on four B300 GPUs.

What is the Beam model ID?

Beam-1.0-501B-A23B on Reflection's API, with the OpenAI-compatible base URL https://api.reflection.ai/openai/v1, and reflection/beam-1.0-501b-a23b on OpenRouter.

Is Reflection AI publicly traded?

No. Reflection AI is a private company with no stock listing and no announced plan to go public. Its 2026 funding valued it at about $25 billion.

Who owns Reflection AI?

It was founded by former Google DeepMind researchers Misha Laskin and Ioannis Antonoglou and is backed by investors including Nvidia, which led its $2 billion round in October 2025.

What is Mirror CLI?

Mirror CLI is Reflection's terminal coding agent. It uses Beam by default, installs with uv tool install reflection-mirror, and runs on macOS 15 or newer and on Linux; on Windows, use it inside WSL.

Can I turn off reasoning in Beam?

No. Beam always reasons. You can choose low, medium, high, xhigh or max effort; none and minimal are rejected with an unsupported_value error.

Is Reflection Beam the same as Reflection 70B?

No. Reflection 70B was a 2024 Llama fine-tune by a different team. Beam is an original model from Reflection AI, the Brooklyn-based lab.

Is Beam on SageMaker JumpStart?

Yes, since October 16, 2026, in US East (N. Virginia) and US East (Ohio). FP8 deploys on ml.p5.48xlarge or ml.p5en.48xlarge, and NVFP4 on ml.p6-b200.48xlarge.

How much does Beam cost on AWS?

The cheapest listed instance, p5.48xlarge, is $55.04 an hour on EC2 on-demand in US East (N. Virginia), about $1,320.96 a day; a SageMaker endpoint charges a higher ml. rate. That day buys about 440 million output tokens on OpenRouter.

Jake kept his subscription and canceled nothing. Eleven days later the weights arrived, the API got a price, and he had the numbers no headline gave him: $1 in, $3 out, and 103 gigabytes for the smallest file. If a launch like this left you wondering whether you missed something, you didn't. Version one of an open model is a promise and a chart. The download, and the bill, are what make it real.

📌 If you keep one line from this page

Active parameters decide how fast a model runs; total parameters decide whether it fits.

Beam is 23B fast and 501B big.

Revision note. Written October 6, 2026, the day after Reflection AI announced Beam. If the headlines had you ready to download it tonight, you were not wrong to be excited; now you know exactly what to wait for. Updated October 17, 2026, after the weights shipped: this page now covers AWS and the API, and the local how-to has its own guide. "All's well that ends well," the proverb says; Beam arrived on time.

Related