Reflection Beam 1.0 Agent Cost: $0.51 a Session

Reflection's Beam 1.0 is out with open weights on Hugging Face. It's a 501B mixture-of-experts model with 23B active parameters, a 1M-token context, an Apache 2.0 license and a training focus on coding agents. Reflection also opened a first-party API and published a setup guide that connects Hermes Agent, OpenCode and Pi to it.

On Together AI the coding session we use for every model comes to $0.51. That's under a quarter of Claude Sonnet 5.5. Two defaults can push that number up, though, and one API rule can kill an agent session halfway through. All three are below, along with the hardware Reflection says you need to run it yourself.

Table of contents

• Beam 1.0 at a glance
• One 60-turn session, priced
• Reasoning is always on, and max is the default
• Connecting Hermes Agent
• What the API leaves out
• Running it yourself
• FAQ
• Sources

Beam 1.0 at a glance

Reflection announced the model on 5 October. Its developer docs, last updated 16 October, now list the open weights, the API and the Mirror CLI beta. Its launch post places Beam level with GLM 5.2 and close to Qwen 3.8-Max on coding and agent tasks, with Kimi K3 still ahead on raw capability. The pitch is efficiency: Reflection says Beam reaches GLM-5.2-level reasoning scores with 3 to 4 times less inference compute, and the model card says it uses about 3 times fewer reasoning tokens than leading open models.

The agent rows from Reflection's own model card (BF16 weights), not yet reproduced by anyone else:

The FP8 and NVFP4 builds land within about 1.5 points of BF16 on most rows. On SWE Bench Pro v2-Hard, NVFP4 scores higher (78.6% against 76.5%).

One 60-turn session, priced

Reflection doesn't publish its own API price on any public page. The billing screen sits behind a login, so the numbers here come from two hosts that list Beam on their pricing pages:

The session is the one from our Sonnet 5.5 vs GPT-6.1 Sol comparison: 60 turns, a 120,000-token prefix sent fresh once and read from cache on the other 59 turns, then 3,000 new input tokens and 1,500 output tokens per turn. That adds up to 7.38 million input tokens (7.08 million of them cache reads) and 90,000 output tokens.

The Sonnet 5.5 figure is from our DeepSeek Flash post, priced from Anthropic's page on 18 October. GLM-5.2 is the model Reflection compares Beam against, and on Together Beam costs about a fifth as much for this session. Four sessions a workday for 20 days comes to $40.90 a month on Together.

Cache reads are 55% of the Together bill. If the host misses the cache on every turn, the same session costs $3.06, six times as much. Together's page lists a cached rate for Beam. That doesn't promise every request will hit the cache, so read cached_tokens in the usage block. Note that Reflection's own API ignores prompt_cache_key and the other prompt cache parameters (see below), so you can't steer caching from the client there.

To run your own turn counts, the API Cost Calculator now has Beam on Together with the cached rate.

Reasoning is always on, and max is the default

Beam has no thinking-off switch. The API accepts reasoning_effort values of low, medium, high, xhigh and max, and none or minimal gets a 400. The example models response shows default_effort: "max" with mandatory: true. Reflection says the default can differ between organizations, so check what GET /models returns for yours.

Reasoning tokens are counted in completion_tokens, which is the output line hosts bill on, and they count against rate limits. The 1,500 output tokens per turn in the table is a modest figure for a model at max effort. If max effort triples output to 4,500 tokens a turn, the Together session goes from $0.51 to $0.73. Cache reads stay the bigger line even then.

For routine agent steps such as reading files, running tests or small edits, set low or medium. Leave max for the turn that has to solve the hard bug.

There's a second cost to the default. The API applies max_tokens: 32768 when a request sets none, reasoning included. If reasoning uses up the budget, the response ends with finish_reason: "length" and content can be null. An agent that reads that as an empty answer just retries, and you pay for the reasoning twice.

Connecting Hermes Agent

Reflection's coding agent guide covers Mirror (its own CLI), Pi, OpenCode and Hermes Agent. All of them talk to an OpenAI-compatible Chat Completions endpoint at https://api.reflection.ai/openai/v1. For Hermes, Reflection gives these commands, tested on Hermes Agent v0.22.2:

export REFLECTION_API_KEY=YOUR_API_KEY
hermes config set model.provider custom
hermes config set model.base_url https://api.reflection.ai/openai/v1
hermes config set model.default Beam-1.0-501B-A23B
hermes config set model.key_env REFLECTION_API_KEY
hermes config set model.reasoning_echo true
hermes config set auxiliary.title_generation.model_upgrade_enabled false
hermes config set auth.adopt_external_logins false

Then test it with hermes chat --oneshot -q "Reply with exactly: pong".

Use the commands rather than editing the file by hand. Reflection warns that a second model section in ~/.hermes/config.yaml makes the file invalid, and Hermes then ignores all of your settings.

reasoning_echo is the line you can't skip. Beam requires reasoning_content on every earlier assistant message you send back, as a non-empty string. The model sometimes returns a tool-call turn with no reasoning. A client that replays that turn without the field gets 400 missing_required_parameter on every request after it, and the session is finished. With reasoning_echo: true, Hermes sends a placeholder for that turn.

The title-generation line exists because Hermes names sessions with a request that has reasoning turned off. Beam always reasons, so it rejects that request. Reflection lists a few other things to expect in Hermes:

• Hermes uses your main model for side tasks such as approval risk scoring and summarizing long conversations, and those calls are billed too. Background review sends the conversation again every 10 turns by default. Turn it off with hermes config set auxiliary.background_review.enabled false.
• Once per session Hermes prints rejected replayed reasoning, then retries with reasoning_content only. The retry succeeds.
• Image analysis fails with 400 invalid_value, because the API takes text only.
• Now and then a turn ends with raw tool-call text and no edit. Check git diff and run the prompt again.

OpenCode reads and returns reasoning_content without extra setup, but it can't recover from a turn that lacks it. You start a new session.

What the API leaves out

The OpenAI-compatible endpoint implements Chat Completions and Models and nothing else. These are the gaps an agent user runs into:

• No Responses API. Reflection says a tool that calls Responses won't work, which rules out Codex as it stands. The docs list no Anthropic-format endpoint, and Claude Code isn't among the agents in the setup guide.
• stop is accepted and ignored. Generation doesn't stop at your stop sequences, so truncate the text yourself.
• seed has no effect, and n must be 1.
• prompt_cache_key, prompt_cache_retention and the related cache fields don't change caching.
• Text input only: no images, audio or files.
• Rate limits are set per organization and shared across all its keys. Some plans have a daily token allowance that resets at 00:00 UTC, which is 05:30 IST. When it runs out the API returns 429 with x-should-retry: false, and the OpenAI SDKs won't retry. For a team in India that limit resets in the early morning, not at midnight.

Running it yourself

Reflection's serving guides for SGLang, vLLM and TokenSpeed all assume one server with four NVIDIA B300 SXM GPUs on NVLink, running the NVFP4 weights (273 GiB) with the DFlash2 drafter for speculative decoding. The vLLM recipe uses --tensor-parallel-size 4, --max-model-len 262144 and --max-num-seqs 8.

The KV cache is small for a model this size. Only 9 of the 52 layers keep the full context. Each one stores 8 KV heads of 128 dimensions, which is 36 KiB per token at BF16 across those 9 layers. A 262,144-token sequence then needs 9 GiB, and all 8 sequences filled to that length need 72 GiB. The other 43 layers keep a 512-token window, about 86 MiB per sequence whatever the length. A full 1M-token sequence needs 36 GiB.

Our AI VRAM Calculator now has a Beam preset that counts only the 9 full-attention layers, so its KV figure matches this math. At 23B active parameters, a single workstation won't hold it. Even a 4-bit build is over 270 GB before any cache.

FAQ

Is Beam on Ollama or LM Studio? Both are listed as inference providers on Reflection's third-party page, next to Together AI, Baseten, Fireworks AI and OpenRouter. Reflection gives no local hardware figures beyond its four-B300 setup.

Can I turn reasoning off for cheap turns? No. low is the lowest effort the API accepts. In the chat template the lowest trained budget is minimal (8), but Reflection's API rejects minimal.

What is the DFlash2 drafter? A separate small model in the reflection/Beam-1.0-501B-A23B-DFlash2 repo, used for speculative decoding with all three weight precisions. The vLLM recipe drafts 8 tokens at a time with it.

Sources

• Reflection, "Introducing Beam: Reflection's 501B open-weight model" (reflection.ai/blog/introducing-beam, 5 October 2026, updated 8 October): parameters, training run, comparisons with GLM 5.2, Qwen 3.8-Max and Kimi K3, compute efficiency claim.
• Hugging Face, reflection/Beam-1.0-501B-A23B model card, config.json and repository metadata (read 19 October 2026): architecture table, benchmark tables, layer types, sliding window, KV heads, head dim, parameter count, license, chat template reasoning budgets.
• Reflection Developer Docs (developers.reflection.ai, read 19 October 2026): Models, Reasoning, OpenAI compatibility, Rate limits, Mirror CLI quickstart (Hermes Agent and OpenCode sections), Download the weights, Serve with vLLM, Third-party providers.
• Together AI pricing (together.ai/pricing, read 19 October 2026): Reflection Beam, Muse Spark Open and GLM-5.2 rates.
• Baseten pricing (baseten.co/pricing, read 19 October 2026): Beam rates.
• Session costs, monthly totals, KV cache sizes, IST conversion and ratios are calculated by ToolMintX from those sources.