DEV Community: Eric Kang

A small acceptance test before scaling an AI workflow

Eric Kang — Sat, 10 Oct 2026 05:42:01 +0000

Model prices are easy to compare. The cost of a useful result takes a little more work.

Before connecting a model to an agent workflow, I suggest writing an acceptance test for a small, representative set of tasks. For a text task, that may mean checking the requested structure and source support. For an image or video task, it may mean checking dimensions, duration and whether the result actually meets the brief.

Record four things for each provider run:

The exact model and output specification.
Every charged attempt, including retries.
Whether the output passed the same acceptance criteria.
The time until an accepted result was available.

A simple calculation is cost per accepted result = total charged cost / accepted outputs. For example, a hypothetical run costing $2 with 40 accepted outputs has a cost of $0.05 per accepted output. That is an example calculation, not a provider price quote.

Keep failure cases in the report. A provider that works well for one task may fail on another, and changing models halfway through a comparison makes the conclusions harder to use.

Disclosure: I work on BeatAPI, the professional capability layer for any agent, described as OpenRouter for Agents. Its current capabilities include text, image and video models, Social Data, SEO Data and Web Search. The checklist above is how I would approach evaluating an API for a particular workload: verify the same model and specification, then measure accepted results before scaling.

What acceptance check has caught the most expensive failure in your own agent workflow?

Claude Haiku 5.5 vs GPT-6 Luna: Pricing & API Guide

Eric Kang — Fri, 09 Oct 2026 14:12:41 +0000

Beat API Team · Specifications and prices checked October 9, 2026

For short summaries, classification, and extraction, evaluate both models against the same acceptance rules. For prompts between 100K and 272K tokens, Luna has the lower official token rates. For tool-driven work, first verify the endpoint and tool loop your application actually uses. A public benchmark can help select candidates, but it cannot decide the production winner for those three workloads.

The Claude Haiku 5.5 vs GPT-6 Luna decision has four parts:

Their official short-context input/output rates match: $0.10/$0.50 per million tokens.
Haiku's higher tier begins above 100,000 prompt tokens; Luna's begins above 272,000 input tokens.
BeatAPI's current short-context retail rates differ: $0.05/$0.25 for Haiku and $0.04/$0.20 for Luna.
A useful result must satisfy the task's meaning and evidence requirements, not merely parse as JSON.

Disclosure: We develop BeatAPI, which publicly lists both exact model IDs. This article distinguishes vendor specifications, a dated public retail listing, and illustrative calculations. We have not conducted a controlled quality or latency comparison, authenticated gateway canary, or billing-boundary experiment for this article.

Claude Haiku 5.5 vs GPT-6 Luna: start with the job

Both models target focused, high-volume work. Both accept text and image inputs and generate text. Haiku advertises a 1M-token context window; Luna advertises 1.05M. Both normally allow up to 128K output tokens. Those limits describe capacity, not retrieval accuracy or a guarantee that your route supports every feature. See the Haiku overview and Luna model reference.

For application builders, the first comparison should look like this:

Job	What counts as accepted	Failure that a leaderboard will not catch
Summarize a customer thread	Correct commitments, dates, unresolved issues, source references	Turns a proposed deadline into an agreed deadline
Classify a support ticket	Correct label under your taxonomy, appropriate abstention	Assigns a refund-policy exception to an ordinary billing queue
Extract a document field	Correct value tied to an actual source span	Returns a plausible number from the wrong reporting period
Choose a tool	Correct permitted tool and arguments, valid authorization context	Produces well-formed arguments for an action the user never authorized
Search a long document	Correct evidence across relevant sections	Misses an exception separated from the main rule

Do not combine all of these into one average score and declare a winner. A model can be excellent at one field extraction while unreliable at interpreting commitments. Different acceptance rules imply different deployment decisions.

Haiku 5.5 pricing vs GPT-6 Luna: the 100K and 272K boundaries

The table below uses official standard API prices in USD per million tokens. It excludes Batch/Flex discounts, paid speed tiers, regional modifiers, and separately charged tools. Cache-writing entries compare published token rates; they do not imply identical cache lifetimes or cache-management behavior.

Token category	Haiku ≤100K	Haiku >100K	Luna ≤272K	Luna >272K
New input	$0.10	$0.50	$0.10	$0.20
Cache read	$0.01	$0.05	$0.01	$0.02
Cache write	$0.125, 5-minute	$0.625, 5-minute	$0.125	$0.25
Output	$0.50	$2.50	$0.50	$0.75

The applicable tier reprices the full request rather than only the excess tokens. Anthropic explicitly includes cache reads and writes in Haiku's prompt length. Luna's model documentation specifies the whole-request increase above 272K input tokens. Sources: Anthropic pricing, OpenAI pricing, and the Luna pricing conditions.

There are therefore three practical zones:

Up to 100K: the listed token rates match for the categories shown.
Over 100K through 272K: Haiku's rates are five times Luna's, assuming the same billable token counts and cache categories.
Over 272K: both use higher rates. Haiku/Luna is 2.5× for new input, cache reads, and the listed cache writes, but about 3.33× for output. The request ratio depends on the mix.

Use model-specific token counts. The same document need not tokenize identically, and the models may generate different amounts of reasoning or visible output. “Same price” is a rate-card statement, not a bill prediction.

BeatAPI's separately verified retail prices

The anonymous BeatAPI price endpoint returned both claude-haiku-5-5 and gpt-6-luna on October 9:

Token category	BeatAPI Haiku: standard	Haiku: long_context	BeatAPI Luna: standard	Luna: 272k_plus
New input	$0.05	$0.25	$0.04	$0.08
Cache read	$0.005	$0.025	$0.004	$0.008
Cache write	$0.0625	$0.3125	$0.05	$0.10
Output	$0.25	$1.25	$0.20	$0.30

Haiku's one-hour cache writes are separately listed at $0.10/$0.50. They are not part of the matched cache-writing row above.

At short-context rates and equal token usage, Luna's listed price is 20% below Haiku's; conversely, Haiku costs 25% more than Luna. Between the vendor boundaries, the retail-rate ratio becomes 6.25×. Those percentages use different denominators—state which one you mean.

This is verification of a public price book. We have not verified real cached requests, long-context settlement, output equivalence, uptime, or model-specific tool support through the gateway. The following retail calculations use the published tier rates with the vendors' boundaries as budgeting assumptions. Recheck current pricing before spending.

If Haiku is a candidate for your workload, BeatAPI’s Claude Haiku 5.5 API page provides its model ID, current token rates, and request examples for the first integration check. Start with a small sample of your own summaries or classification inputs, then apply the same acceptance rules to Luna; the price table alone is not a reason to choose Haiku.

Seven request budgets that make the boundaries visible

Use disjoint token buckets:

cost = (new_input × input_rate
      + cache_read × read_rate
      + cache_write × write_rate
      + billed_output × output_rate) / 1,000,000

Output means the entire billed output count, including reasoning where applicable. Cache-hit scenarios below omit the earlier write expense. Equal token counts are an analytical assumption, not observed model behavior.

Assumed request	Official Haiku	Official Luna	BeatAPI Haiku	BeatAPI Luna
2K new input + 500 output	$0.00045	$0.00045	$0.000225	$0.00018
100,000 new input + 2K output	$0.011	$0.011	$0.0055	$0.0044
100,001 new input + 2K output	$0.0550005	$0.0110001	$0.02750025	$0.00440004
150K new input + 2K output	$0.080	$0.016	$0.040	$0.0064
190K cache read + 10K new input + 2K output	$0.0195	$0.0039	$0.00975	$0.00156
272,001 new input + 2K output	$0.1410005	$0.0559002	$0.07050025	$0.02236008
400K new input + 5K output	$0.2125	$0.08375	$0.10625	$0.0335

These are reproducible arithmetic examples, not measured invoices. They exclude tools, validators, retries, and human review.

The 200K cache-hit example illustrates an especially useful distinction: only 10K tokens are new, yet Haiku belongs to the higher tier because the cached prompt is still present. A dashboard showing only new input would hide that cause of the bill.

The 400K example also shows why “Haiku costs 2.5× more above 272K” is incomplete. Input has that ratio, but output has a different ratio. The total is about 2.54× at official rates and 3.17× at the listed BeatAPI rates for this particular token mix.

Splitting a long document creates another comparison

Take the 150K-input, 2K-output example. A direct Haiku request costs $0.080 at official rates; direct Luna costs $0.016.

Suppose a different Haiku workflow uses three requests, each with 50K total input and 500 output, followed by a synthesis request with 5K total input and 1K output. The three extraction calls cost $0.01575; synthesis costs $0.001. Total: $0.01675. At the listed BeatAPI rates, this becomes $0.008375 versus $0.0064 for direct Luna.

The chunked Haiku workflow is cheaper than direct Haiku under these assumptions, but is still more expensive than direct Luna. It also changes the task: evidence crossing chunk boundaries may disappear, the synthesis adds another failure point, and total output differs from the direct request.

Use chunking when the acceptance rubric permits independent extraction plus synthesis. Add overlap, repeated instructions, retrieval misses, retries, and final verification to the real budget. “Keep each chunk under 100K” is not sufficient to establish a better system.

How much better must Haiku be to justify a higher bill?

Let C_H and C_L be average total cost per incoming task for each candidate route, including failed attempts. Let s_H and s_L be their fractions of accepted tasks. The cost per accepted task is:

Haiku: C_H / s_H
Luna:  C_L / s_L

With nonzero acceptance rates, Haiku is cheaper per accepted result only if:

s_H / s_L > C_H / C_L

For the short-request BeatAPI example, the cost ratio is 1.25. If Luna accepts 70% of tasks, Haiku must accept more than 87.5% to be cheaper per accepted result under these fixed token assumptions. If Luna already accepts 90%, Haiku cannot offset a 25% premium through acceptance rate alone: it would need more than 112.5% acceptance.

For the 150K example, the retail cost ratio is 6.25. If Luna accepts 80%, an impossible 500% Haiku acceptance rate would be required to reverse that comparison through acceptance rate alone.

These examples do not measure either model's actual acceptance rate. They explain why a general benchmark advantage cannot automatically justify a large task-specific price difference. Higher accuracy can still be worth paying for if errors have material costs, but then include those costs explicitly rather than calling the inference cheaper.

A broader business estimate is:

total_cost = inference + tools + validation + rework + error_cost

For example, paying a few extra cents to prevent a document error that needs ten minutes of review can be rational. Conversely, a slightly better benchmark score has little value for a ticket classifier if both models already satisfy the operational acceptance threshold.

Always report acceptance rate alongside cost per accepted result. Otherwise, rejecting most difficult tasks can make a route appear efficient while failing to serve users.

What the published benchmarks add

Anthropic's Haiku announcement reports these shared rows:

Published evaluation	Haiku 5.5	GPT-6 Luna
OSWorld 2.1, offline subset	72.4%	48.9%
Terminal-Bench 4.0	39.2%	16.4%
FrontierCode 1.1 Main	46.4%	42.4%
GDPval-AA v2.1	1620	1437

These are vendor-published results, not our independent reproduction or a matched-budget experiment through BeatAPI. The OSWorld subset qualification matters. GDPval is an Elo-style score, not a success percentage. Neither result establishes your model's accuracy on a particular support taxonomy or document set.

Use the table to include Haiku in an agent-work evaluation. Do not conclude that it will generate fewer tokens, need fewer retries, or finish sooner in your application. Those are separate measurements. A claim about being the fastest model within one vendor's range is also not a cross-vendor latency result.

Reasoning settings with the same name do not guarantee equal compute or equal quality. A comparison at low on both systems is a useful configuration test. A second comparison tuning each system to the same acceptance target answers the production question more directly.

API compatibility is part of the model choice

Haiku uses the Messages request shape, with output_config.effort. Luna's Responses request uses reasoning.effort. Luna's official model page recommends Responses for built-in tools and function calling; Chat Completions function calling is limited to reasoning_effort: none. See the Luna reference.

For Haiku, the migration guide documents sampling-parameter restrictions, adaptive thinking, and assistant-prefill changes. Read answer blocks by type instead of assuming the first block is text. Reasoning can consume an output limit before the visible answer is complete.

BeatAPI's gateway contract exposes /v1/messages and /v1/responses. Exposing those route names does not by itself establish feature parity with either vendor's hosted tools or guarantee a particular parameter will pass through unchanged. Validate the actual route with a small canary before enabling it for users.

For a text-only classification pilot, use the same substantive prompt with separate adapters:

Classify the ticket as billing, bug, feature, or needs_review.
Return only a JSON object with exactly label and evidence.
Evidence must be a nonempty exact quote from the ticket.
Use needs_review when intent is missing or conflicting.
Do not execute any action.

Ticket: I was charged twice for the same invoice.

Haiku request, sent to POST /v1/messages:

{
  "model": "claude-haiku-5-5",
  "max_tokens": 4096,
  "output_config": {"effort": "low"},
  "messages": [{
    "role": "user",
    "content": "Classify the ticket as billing, bug, feature, or needs_review. Return only a JSON object with exactly label and evidence. Evidence must be a nonempty exact quote from the ticket. Use needs_review when intent is missing or conflicting. Do not execute any action. Ticket: I was charged twice for the same invoice."
  }]
}

Luna request, sent to POST /v1/responses:

{
  "model": "gpt-6-luna",
  "max_output_tokens": 4096,
  "reasoning": {"effort": "low"},
  "input": "Classify the ticket as billing, bug, feature, or needs_review. Return only a JSON object with exactly label and evidence. Evidence must be a nonempty exact quote from the ticket. Use needs_review when intent is missing or conflicting. Do not execute any action. Ticket: I was charged twice for the same invoice."
}

These payloads are integration examples, not proof that either model obeys the requested format. Use your API key through the normal authenticated transport; never put credentials in a public article or evaluation artifact. Do not execute these requests merely to reproduce the offline budget tables—they are billable. Field shapes follow the vendor reasoning guidance and Haiku migration reference; authenticated gateway forwarding is untested here.

Validate meaning as well as JSON

For this tiny labeled fixture, the following gate rejects malformed output, an incorrect label, empty evidence, and invented quotes:

import json

def accept(raw_text, ticket, expected_label):
    try:
        answer = json.loads(raw_text)
    except (ValueError, TypeError):
        return False
    if not isinstance(answer, dict) or set(answer) != {"label", "evidence"}:
        return False
    return (
        answer["label"] == expected_label
        and isinstance(answer["evidence"], str)
        and bool(answer["evidence"].strip())
        and answer["evidence"] in ticket
    )

An exact quote is a grounding check, not proof of entailment. In the example, a quote about the invoice does not alone prove a duplicate charge. For a real extraction or summary task, the rubric must check that the cited passage supports the claim. The expected label comes from a held-out human-labeled test set; it is not available for arbitrary production tickets.

This makes the boundary between evaluation and runtime validation explicit. Runtime schema checks can reject invalid format. They cannot magically know the correct answer. Use audited labels to estimate false acceptance and decide when manual review is needed.

Tool calls need their own acceptance rules

Before dispatching a model-generated call, check the tool name against an allowlist, validate argument types and ranges, confirm the referenced record exists, and preserve the application's authorization checks. Then evaluate whether the selected tool is semantically appropriate for the request.

For a duplicate-charge ticket, “classify as billing” and “refund the payment” are different tasks. A perfect JSON refund call is still wrong if the application only requested classification. Use a read-only sandbox or mocked tool executor for the initial model comparison so you can grade the proposed actions independently of their execution.

An evaluation plan for summaries, classification, and tools

Build three separate held-out sets. Keep ordinary examples, ambiguous examples, and known failure cases in each. A small pilot is useful for fixing adapters and rubrics; it does not establish a very low production error rate.

Task family	Primary metric	Additional check
Summaries	Required-fact coverage with no unsupported commitments	Dates, named owners, unresolved conflicts, source support
Classification	Per-class precision/recall and macro-F1	Abstention rate, rare categories, misrouting severity
Tool calls	Correct allowed tool and arguments	Authorization, abstention when inputs are missing, executor errors

Run the same task IDs through both models. Preserve prompts, source snapshots, schemas, output limits, model IDs, settings, and every attempt. Grade without model names where practical. Do not drop truncations or invalid JSON from the denominator.

For each family, record:

Total billed tokens by category, with reasoning included where reported.
Cold-cache and warm-cache costs separately, including write expenses.
Accepted fraction, false acceptance, retries, escalation, and manual review.
End-to-end duration and, if streaming, time to first token separately.
The applicable request tier and full input length for every call.

A useful final comparison has two views: the same nominal settings for both candidates, and the least expensive tested configuration that meets the same acceptance and latency targets. Keep the second view within the tested range; do not interpolate an unmeasured configuration into a claimed winner.

You may end up choosing Luna for long-document extraction, Haiku for a particular short agent task, and either for a classifier. That is a valid result. The purpose is a defensible routing decision, not a universal ranking.

FAQ

Why can a cheaper model still cost more in an agent session?

The total bill combines per-token rates with the number of requests, prompt length, cache hits, and billed output. To audit a claimed cost gap, export each request's usage and tier; separate fresh input, cache reads, cache creation, and output. Compare the same source files, tools, stopping rule, and acceptance rubric in fresh workspaces. Otherwise, a model that reuses earlier generated files may appear cheaper for reasons unrelated to capability. An API-equivalent estimate from a subscription is also different from an actual API invoice. The worked budgets above hold token counts fixed; they explain pricing mechanics rather than reproduce a viral demo.

Which model is faster?

This article has no controlled latency result. Measure time to first token for an interactive UI, then total time to an accepted result for an agent. Include tool waits, retries, and verification. A shorter answer can finish sooner while failing the task, and the same effort label need not mean the same compute budget.

Is Haiku 5.5 cheaper than GPT-6 Luna?

Their official short-context rates match for the categories compared here. At BeatAPI's checked short-context rates, Luna is 20% cheaper under equal token usage. Above 100K and through 272K, Haiku's higher tier widens that difference. Real task cost still depends on usage and acceptance.

Which one is better for summaries?

Test required-fact coverage and unsupported claims on your actual documents. A fluent summary that changes a commitment or drops an exception should fail, even if it is shorter and cheaper.

Which one is better for classification?

Use your taxonomy, hard labels, rare classes, and an abstention policy. A broad knowledge benchmark is not evidence of correct routing in your support system.

Do cache hits avoid Haiku's higher tier?

No. Anthropic explicitly counts cached input toward prompt length. The low number of newly supplied tokens does not describe the whole prompt.

Is splitting documents always the economical choice?

No. Count extraction, synthesis, overlap, retries, and verification. The worked chunking example remains more expensive than direct Luna and changes the information flow.

Can both models use the same API payload?

Do not assume that. Keep endpoint-specific adapters and model-specific options. Verify tool support and output parsing on the exact route you will deploy.

Can public benchmark scores justify paying more?

They can justify testing a candidate. To justify deployment, measure task-specific acceptance, latency, and rework. Use the cost-per-accepted-result inequality to assess the premium.

Have these results been measured through BeatAPI?

The public retail listing was verified. The workload costs are arithmetic, and the request payloads are examples. No authenticated quality, latency, or boundary-settlement test is claimed.

For Claude Haiku 5.5 vs GPT-6 Luna, start with one narrow workload, preserve its evidence, and measure what it costs to produce an answer you can actually use. Long-context pricing can choose the first candidate; a clear acceptance rubric should choose the production route.

Claude Haiku 5.5 vs Opus 5.5: Pricing & API Guide

Eric Kang — Fri, 09 Oct 2026 14:09:41 +0000

By Beat API Team · Prices and documentation checked October 9, 2026

Start with Haiku 5.5 for bounded, verifiable tasks. Start with Opus 5.5 when the task requires sustained reasoning across files, tools, or conflicting evidence. For applications containing both kinds of work, evaluate a Haiku-first route with explicit acceptance checks and an Opus escalation path.

The Claude Haiku 5.5 vs Opus 5.5 comparison turns on pricing, cache behavior, and the cost of completing your task:

Haiku's official uncached input/output rates are 40 times lower for prompts up to 100,000 tokens, but only eight times lower above that boundary.
Cache reads count toward that boundary. A small new message attached to a large cached conversation still belongs to the long-prompt tier.
Identical context limits do not imply identical ability to complete a task—or identical bills.
Measure cost per accepted result, including retries and escalation. A cheap first attempt can leave expensive rework.
API migration includes request parameters and response parsing; changing the model ID alone is insufficient.

Disclosure: We build BeatAPI, which lists both models. This article separates Anthropic's published specifications, BeatAPI's dated public retail listing, and our own arithmetic and implementation recommendations. We have not run a controlled Haiku-versus-Opus quality or latency benchmark for this article.

Claude Haiku 5.5 vs Opus 5.5: what actually differs?

Both models accept text and image inputs and return text. Both advertise a 1M-token context window and a normal maximum output of 128K tokens. Haiku 5.5 was released on October 7; Opus 5.5 on September 22. Haiku is positioned for classification, extraction, routing, and subagent work; Opus for long-running coding and knowledge work. These are model specifications, rather than guarantees for every gateway, account, or integration. See the Haiku overview and Opus overview.

That distinction suggests a useful first split:

Workload	Initial candidate	Acceptance check	Escalation trigger
Classify a support ticket	Haiku	Allowed label, explicit intent, known exceptions	Multiple intents or policy ambiguity
Extract a field from a document	Haiku	Value exists in a cited source span	Conflicting records or missing evidence
Find likely files for a bug	Haiku	Existing paths and relevant symbols	Scout cannot justify the shortlist
Fix a multi-file regression	Opus	Reproduction, regression tests, diff review	Review or test failure
Reconcile conflicting documents	Opus	Traceable claims and resolved contradictions	Evidence remains incomplete
Write a summary for a recurring report	Haiku for extraction; evaluate Opus for synthesis	Source coverage and figure checks	Cross-document inference or high rework rate

This is a proposed routing policy. A simple task with unusual domain rules can still be difficult, while a large document with one exact lookup may be easy. Start with representative examples from your application before assigning a whole category to either model.

Haiku 5.5 pricing vs Opus: input, output, and cache costs

The following are Anthropic standard API prices in USD per million tokens, excluding Fast mode, Batch discounts, geography modifiers, and separately billed tools.

Token category	Haiku: prompt ≤100K	Haiku: prompt >100K	Opus: standard
New input	$0.10	$0.50	$4.00
Output	$0.50	$2.50	$20.00
Cache read	$0.01	$0.05	$0.20
5-minute cache write	$0.125	$0.625	$5.00
1-hour cache write	$0.20	$1.00	$8.00

For uncached input and output, Opus/Haiku is 40× below or at 100K and 8× above it. For cache reads alone, those ratios become 20× and 4×. A workload mixing these buckets has its own ratio. Rates and the counting rule come from Anthropic's pricing documentation.

The boundary applies to the whole request, rather than a marginal surcharge on tokens after 100K. Prompt length includes new input, cache reads, and cache writes. Output does not determine prompt length, but its rate changes when the prompt crosses the boundary. Earlier requests retain their original prices.

This matters when a conversation grows gradually. One additional tool result can move the next request into a different tier even if most of its context is cached.

BeatAPI's separately verified retail listing

On October 9, the anonymous BeatAPI pricing endpoint listed these rates for the exact IDs claude-haiku-5-5 and claude-opus-5-5:

Token category	BeatAPI Haiku: standard	BeatAPI Haiku: long_context	BeatAPI Opus
New input	$0.05	$0.25	$2.00
Output	$0.25	$1.25	$10.00
Cache read	$0.005	$0.025	$0.10
5-minute cache write	$0.0625	$0.3125	$2.50
1-hour cache write	$0.10	$0.50	$4.00

These published rates are half the corresponding Anthropic standard rates. The listing verifies a public price book; it does not independently establish output equivalence, uptime, end-to-end latency, or support for every Anthropic feature. The endpoint exposes both Haiku tiers; the 100K rule described above is independently documented by Anthropic. Boundary settlement through BeatAPI has not been tested here. Recheck current pricing before budgeting.

For an implementation check, the Claude Haiku 5.5 API page and Claude Opus 5.5 API page on BeatAPI bring the model IDs, current token rates, and request examples together. Use those examples to test one representative task before adopting the routing policy below.

Five workloads you can calculate before calling either model

For disjoint token buckets, a token-only estimate is:

cost = (new_input × input_rate
      + cache_read × read_rate
      + cache_write_5m × write_5m_rate
      + cache_write_1h × write_1h_rate
      + output × output_rate) / 1,000,000

Do not add cached tokens to both new input and cache read. For the examples below, output means the full billed output token count, including reasoning where applicable, rather than just the visible answer. The token counts are assumed identical between models to isolate pricing; real model runs will usually differ.

Assumed request	Anthropic Haiku	Anthropic Opus	BeatAPI Haiku	BeatAPI Opus
2K new input + 500 output	$0.00045	$0.018	$0.000225	$0.009
90K cache read + 10K new input + 2K output	$0.0029	$0.098	$0.00145	$0.049
190K cache read + 10K new input + 2K output	$0.0195	$0.118	$0.00975	$0.059
100,000 new input + 2K output	$0.011	$0.440	$0.0055	$0.220
100,001 new input + 2K output	$0.0550005	$0.440004	$0.02750025	$0.220002

These are illustrative calculations, not observed invoices or benchmark results. Cache-hit examples exclude the earlier cost of creating the cache. BeatAPI columns apply its published tier rates with Anthropic's documented boundary as the budgeting assumption.

Two consequences are easy to overlook:

First, the cache-heavy 200K example makes Opus about 6.05× as expensive, rather than 40×. Most of the prompt is cheap cache-read traffic, while Haiku has crossed into its higher tier.

Second, at this output length, increasing an uncached Haiku prompt from 100,000 to 100,001 tokens increases the estimated request cost roughly fivefold. Opus's estimate changes only by the additional input token. This is why token counting belongs before routing, especially near the boundary.

For the small-request example, one million requests would cost $450 on Anthropic Haiku or $18,000 on Anthropic Opus. BeatAPI's listed rates imply $225 or $9,000. Those totals assume one attempt per request, unchanged token usage, no tools, and no other charges. They are planning scenarios, not promised savings.

When is compaction worth paying for?

Suppose the next ten requests each read 190K cached tokens, add 10K new tokens, and generate 2K output tokens. At Anthropic rates, Haiku costs 10 × $0.0195 = $0.195.

If a validated summary lets each request read 90K cached tokens instead, the ten requests cost 10 × $0.0029 = $0.029. That leaves $0.166 for creating the summary and writing its replacement cache before the token-only saving disappears. At BeatAPI's listed rates, the corresponding allowance is $0.083.

For example, writing a 90K replacement cache at Haiku's five-minute standard rate costs $0.01125 at Anthropic rates. The cost of generating the summary is additional. You also need to account for cache expiration and misses.

The important qualification is semantic: a cheaper summary that loses the one detail needed later can increase retries or produce a wrong answer. Preserve source references and measure downstream acceptance. Compaction is an optimization to evaluate, rather than a universal instruction to shorten everything.

What the published benchmarks can—and cannot—tell you

Anthropic reports 39.2% for Haiku 5.5 and 66.4% for Opus 5.5 on Terminal-Bench 4.0, and 46.4% versus 54.4% on FrontierCode 1.1 Main. The reported GDPval-AA v2.1 scores are 1620 and 1846, respectively. Sources: the Haiku announcement and Opus announcement.

These published results help choose what to test first. They do not provide your application's success probability. The Opus announcement specifies xhigh effort for Terminal-Bench and generally max effort for other reported results, and describes safeguard fallbacks in some evaluations. These figures are not a controlled comparison at equal effort, equal cost, or through BeatAPI. Avoid turning them into claims about a specific production route.

Some apparently comparable visual scores also use different tool conditions or subsets. A result with tools and a result without tools should not be presented as a clean model-only ranking. Likewise, Elo scores are not percentages: a higher GDPval score does not imply a proportional increase in accepted tasks.

A useful evaluation separates three questions:

Capability: Can the model complete the task under the allowed tools and context?
Economics: What does an accepted result cost with the actual request sequence?
Product experience: Does it meet the latency and correction burden users can tolerate?

Keep these measurements separate. The least expensive accepted answer may still arrive too late for an interactive workflow.

A Haiku-first route needs a rejection policy

A practical candidate architecture is:

Task → explicit complexity rules
       ├─ known complex task → Opus → acceptance check
       └─ bounded task → Haiku → deterministic checks
                              ├─ accepted → return
                              └─ unresolved → Opus with source evidence

Use observable evidence for the gate. For extraction, require a source span and validate the requested field. For code, run the reproduction and regression tests. For classification, check the allowed categories and evaluate difficult labeled examples. A model saying “I am confident” is not an acceptance test.

Do not let Opus see only Haiku's conclusion when escalating a disputed result. Pass the original source, the relevant excerpt, and the failed check; identify Haiku's draft as an unverified candidate. Otherwise, escalation can amplify the first model's mistake.

The escalation break-even formula

Let H be average Haiku cost per incoming task, Oe the Opus cost when escalated, Od the cost of sending that task directly to Opus, V validation overhead, and p the escalation fraction. A one-attempt Haiku route costs:

expected_cost = H + V + p × Oe

It is cheaper than direct Opus when:

p < (Od - H - V) / Oe

If escalation and direct Opus cost the same and validation is free, this simplifies to p < 1 - H/Od.

With the small-request assumptions above, H = $0.00045 and Oe = Od = $0.018. If 20% escalate, the result is $0.00405 per incoming task, 77.5% below sending every task directly to Opus. At BeatAPI's listed rates it is $0.002025 versus $0.009, with the same relative saving under identical assumptions.

This is a sensitivity example, not a measured 20% escalation rate. If Opus needs to reread more context or correct a damaged draft, Oe may exceed Od. Add all failed attempts, validator calls, tools, and review time before claiming a production saving.

Also measure false acceptance: how often an incorrect Haiku result bypasses escalation. Lower escalation is not an improvement if the gate silently returns more wrong answers.

Migration traps that affect the comparison

Haiku 5.5's migration guide documents changes beyond the model ID:

Old assumption	Adjustment
Token counts measured on Haiku 4.5 still apply	Recount using the new model; the tokenizer can produce approximately 30% more tokens for the same text
Fixed `thinking.budget_tokens` controls reasoning	Use adaptive thinking and `output_config.effort`
`temperature=0` makes extraction predictable	Remove sampling parameters; use explicit requirements and validation
`content[0]` is always the answer	Collect blocks whose `type` is `text`
A tiny `max_tokens` cap is sufficient	Reasoning can consume the cap before visible text appears
Assistant prefill enforces JSON	Replace prefill with a supported output mechanism and validate the result

Opus has its own differences: adaptive thinking cannot be disabled and forced tool use returns an error. A shared router should maintain model-specific capability settings, rather than passing every Haiku request option unchanged to Opus. See the Opus overview.

A minimal two-model request

BeatAPI's public gateway contract exposes POST /v1/messages. This example uses that route and asks both models the same bounded question. It is an integration example; authenticated execution and model-specific parameter forwarding have not been tested for this article. Confirm them with a small canary before using the code in production.

export BEATAPI_API_KEY='YOUR_API_KEY'
# Save the Python example below as compare.py, then:
python3 compare.py

import json
import os
import time
import urllib.request

key = os.environ["BEATAPI_API_KEY"]
prompt = """Classify this ticket as billing, bug, or feature.
Return only a JSON object with label and a short evidence quote.
Ticket: I was charged twice for the same invoice. Can you refund one charge?
Do not take any action on the account."""

for model in ("claude-haiku-5-5", "claude-opus-5-5"):
    body = {
        "model": model,
        "max_tokens": 4096,
        "output_config": {"effort": "low"},
        "messages": [{"role": "user", "content": prompt}],
    }
    request = urllib.request.Request(
        "https://api.beatapi.io/v1/messages",
        data=json.dumps(body).encode(),
        headers={
            "Authorization": "Bearer " + key,
            "Content-Type": "application/json",
            "anthropic-version": "2023-06-01",
        },
        method="POST",
    )
    start = time.monotonic()
    with urllib.request.urlopen(request, timeout=90) as response:
        result = json.load(response)
    text = "".join(
        block.get("text", "")
        for block in result.get("content", [])
        if block.get("type") == "text"
    )
    print(json.dumps({
        "model": model,
        "elapsed_seconds": round(time.monotonic() - start, 3),
        "stop_reason": result.get("stop_reason"),
        "usage": result.get("usage"),
        "answer": text,
    }, ensure_ascii=False))

This makes two billable requests when run. It records total non-streaming request duration, not time to first token. It does not guarantee valid JSON, implement retries, or form a benchmark. Validate the returned object and inspect stop reasons before treating the result as accepted. Avoid logging sensitive tickets or credentials in production.

Start a new, source-based request when escalating between models. Cross-model or cross-account replay of opaque thinking blocks is not a safe generic routing strategy; preserve those blocks only as required by the original conversation's API rules.

How to run an evaluation that answers your routing question

Use a held-out set with ordinary cases and deliberately hard cases. A pilot of 50–100 labeled examples can reveal integration and rubric problems; it is too small to establish a low production error rate.

Measurement	What to retain	Why it changes the decision
Accepted-result rate	Expected result, rubric, observed output	Distinguishes useful answers from plausible prose
False acceptance	Gate decision and independent correctness label	Finds errors that escalation never sees
Cost per accepted result	Every attempt's usage and applicable rates	Includes failures and rework
End-to-end latency	Start, finish, tool and review time	Captures the actual user wait
Escalation fraction	Route and rejection reason	Tests the routing cost formula
Cache behavior	Writes, reads, misses, total prompt length	Separates warm-cache estimates from real traffic

Keep prompts, tools, input snapshots, output limits, and grader rules fixed. Alternate model order to reduce time-of-day bias. Run a matched-effort comparison first, then allow each model a tuned configuration: those answer different questions. Record all attempts, rather than keeping only the nicest response.

For a three-route experiment—Haiku only, Opus only, and Haiku with escalation—evaluate the same task IDs. The routing experiment must grade final delivered answers and record both model calls where escalation occurs. Do not compare a routed system's final success rate with a single model's first-attempt success rate without labeling that difference.

For a business-facing metric, calculate:

cost_per_accepted_result =
    (all inference + tools + validators + review cost) / accepted_results

If no result is accepted, report the metric as undefined rather than zero. Rejected tasks still contributed cost. Report the acceptance rate beside this metric so a route cannot appear efficient simply by dropping hard cases.

Questions worth answering before switching

Is Haiku 5.5 a replacement for Opus 5.5?

It is a candidate replacement for particular task classes once they meet your acceptance bar. A file scout and a migration planner can belong in the same application while requiring different models.

Is Haiku always 40 times cheaper?

No. That ratio applies to equal uncached input/output token counts at standard rates with prompts up to 100K. Long-prompt rates, caching mixes, generated reasoning, and retries change the comparison.

Does caching keep Haiku under the 100K boundary?

No. Cached input still contributes to prompt length. Count the complete prompt before choosing a tier.

Does a 1M context window mean I should send the whole repository?

No. It is capacity, not a retrieval strategy. Test whether a relevant slice preserves acceptance while reducing cost and latency. Keep source references available for follow-up.

Can I compare API bills with a Claude subscription?

Not directly. This article models per-token API rates. Subscription allowances, usage accounting, and user workflows are a separate comparison.

Is Haiku faster in my application?

Anthropic positions it as its fastest standard-speed model. That does not predict latency on your route or workload. Measure end-to-end completion and time to first token separately, including tools and escalation.

What should I deploy first?

Choose one bounded, labeled workload. Check the model ID and request shape, capture actual usage, validate results, and compare all three routes. Expand only after the candidate route meets your correctness and latency requirements.

The practical decision in Claude Haiku 5.5 vs Opus 5.5 is where to spend reasoning. Give narrow, checkable work to the inexpensive candidate; spend more on unresolved complexity; and make the acceptance check strong enough to know the difference.

Where Can I Get a Free DeepSeek API for Small Automations?

Eric Kang — Fri, 02 Oct 2026 10:40:27 +0000

Where can I get a free DeepSeek API?

BeatAPI provides a free DeepSeek API through its DeepSeek V4.1 Flash route. It uses deepseek-v4.1-flash-free, with $0 input and output. The account limit is one successful request per minute before the first top-up and up to ten afterward. A small automation should therefore queue requests, wait after HTTP 429, and save each completed result before starting the next item.

Create a BeatAPI key in the default auto group and select the free model explicitly.
Send one request at a time, with spacing appropriate to your account's free limit.
Retry rate limits a bounded number of times; stop on an authentication or configuration error.
Resume unfinished items instead of rerunning the whole batch.
Keep paid fallback disabled unless you have deliberately budgeted for it.

Start with the DeepSeek V4.1 Flash API page. The public gateway price book lists the explicit free model separately from the paid model. The gateway capability catalogue confirms its current routes and limits; the landing page may still show the paid model by default. Select the free ID in this guide explicitly, and recheck availability before depending on it. This guide focuses on a small, resumable text workflow. The broader OpenAI SDK migration guide covers changing an existing application.

Free DeepSeek API access: the exact configuration

Question	BeatAPI route
Where do I get the key?	Dashboard → API keys, default `auto` group
Which model is free?	`deepseek-v4.1-flash-free`
OpenAI-compatible base URL	`https://api.beatapi.io/v1`
Request formats	Responses or Chat Completions
Free input and output pricing	$0
Initial frequency limit	One successful request per minute per account
After any top-up	Up to ten successful requests per minute; model remains free

A free DeepSeek API is different from a free chat website, an open-weight download, free cached input, or a one-time credit grant. Those options do not automatically provide hosted, zero-priced input and output for your application. Match the key issuer, endpoint, model ID, and current terms before comparing offers.

For the free DeepSeek API in this guide, the distinctive question is whether a paced workload fits the allowance. The next sections show how to preserve progress, rather than treating free access as unlimited capacity.

Compare free DeepSeek API allowances before choosing

The same search can return three different offers. Check the exact model and the unit in which the allowance is measured:

Route	Published allowance checked October 2, 2026	What to compare
Cloudflare Workers AI	10,000 Neurons daily	Its listed R1 distill is a different model; V4 Flash and Pro require a paid billing method
Hugging Face Inference Providers	$0.10 in monthly credits for free accounts, subject to change	A credit budget, rather than zero-priced inference; verify model availability separately
Fireworks	$1 starter credits	Initial trial funding; the pricing page does not promise a recurring refill
BeatAPI free DeepSeek API	$0 input and output on the explicit free Flash model	Account-wide frequency limits govern a paced workload; availability may change

Choose a free DeepSeek API by workload, not just the word “free.” A daily compute allowance can suit experiments with a distill; a credit grant can fund a brief model evaluation. BeatAPI's route is worth evaluating when you specifically want Flash with zero-priced input and output and can tolerate a slow queue. Do not convert Neurons or dollars into guaranteed calls without a measured token budget.

Why free DeepSeek API automations keep restarting

A developer reported in the QwenPaw project that free DeepSeek requests were hitting rate limits during multi-step jobs, causing repeated restarts. That report concerns their configured service, rather than a test of BeatAPI, but the workflow question is useful: how should an automation preserve progress when model access pauses?

HTTP 429 means the current request cannot proceed under the service's rate policy. It does not mean every previous result is invalid. Restarting the entire workflow repeats successful work and adds more requests precisely when capacity is constrained.

Split the job into individually identifiable units. For a batch of release notes, use one record per note, with a stable input ID, status, model ID, result, and request identifier if supplied. Mark a record complete only after validating and saving its answer.

What fits the free DeepSeek API rate limits?

Task	Free route fit	Application design
Try one prompt or summarize one note	Useful starting point	One request; inspect the answer
Process a small backlog without a deadline	Reasonable experiment	Paced queue and saved progress
Interactive assistant with many simultaneous users	Poor fit at the initial limit	Measure demand and choose an appropriate service tier
Long autonomous loop with repeated tool calls	Requires careful evaluation	Count calls per task and plan pause/resume behavior

Ten successful calls require roughly ten minutes of capacity at one call per minute, or roughly one minute at ten calls per minute. These are planning estimates, not delivery promises: latency, retries, other workers on the same account, and changing availability add time.

The limit is account-wide. Starting five workers with different keys does not create five independent free allowances. A scheduler must coordinate all callers that share the account.

Test the free DeepSeek API before building the queue

Set BEATAPI_API_KEY in your server environment, then run:

curl --fail-with-body https://api.beatapi.io/v1/chat/completions \
  -H "Authorization: Bearer $BEATAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4.1-flash-free",
    "messages": [{
      "role": "user",
      "content": "Summarize this release note in one sentence: We added CSV export and fixed duplicate rows in downloads."
    }],
    "max_tokens": 128
  }'

This is a request example, not a published live benchmark. Inspect the HTTP status and returned content in your own environment. A 200 response alone does not prove the summary is correct. Keep the key out of browser code and workflow exports.

The live gateway capability catalogue also lists POST /v1/responses for the free route. Choose one format for your experiment; do not infer that every format available on a paid model is also available on its free route. See the DeepSeek model documentation.

Queue free DeepSeek API calls and resume unfinished work

Use this application-side algorithm as a starting point:

Read the next unfinished item from durable storage.
Wait until the shared account scheduler grants a request slot.
Call the explicitly configured free model.
If 200: validate the answer, save it, and mark this item complete.
If 429: honor Retry-After when present; otherwise back off.
Retry the same item at most three times, then leave it pending.
If a permanent request/authentication error occurs: stop and fix it.
After a timeout: record the uncertainty before deciding to retry.

For one worker on an account with no top-up, spacing requests at least 60 seconds apart is a conservative starting policy. Slightly more spacing can absorb clock and scheduling differences. It is not a guarantee against 429. After a top-up, the documented upper limit is ten successful calls per minute; keep coordination account-wide.

In n8n, the HTTP Request node exposes batch size and batch interval controls. One item per batch and a suitable interval can pace a single execution. Overlapping executions still need shared coordination; a node setting does not create an account-wide scheduler.

Configure a maximum waiting budget too. If the job can wait five minutes, let it remain pending after that budget rather than sleeping indefinitely or discarding its completed records. Save progress in your own storage; BeatAPI does not provide your application's queue.

Free DeepSeek API example: twelve release-note summaries

Assume twelve notes, each processed independently. The first four summaries have been validated and saved, then the fifth request receives 429.

The correct recovery starts with note five. Keep notes one through four complete; apply the service's waiting guidance and retry note five within your retry budget. If recovery is exhausted, retain notes five through twelve as unfinished. The next run reads those records and continues.

At the initial one-per-minute limit, budget roughly twelve minutes of request capacity for the full run, plus generation and recovery time. This workload is a useful free experiment if it can wait. A five-second response deadline for all twelve notes calls for another design.

Track three outcomes separately: request success, answer acceptance, and record completion. An empty or unusable answer should not become a completed note merely because the request succeeded.

Keep free DeepSeek API calls separate from paid fallback

Mistake	Fix
Send `deepseek-v4.1-flash` while expecting free usage	Pin `deepseek-v4.1-flash-free` in the request configuration
Retry 429 immediately in a tight loop	Wait and enforce both attempt and elapsed-time budgets
Restart all twelve items after one failure	Persist completion per input ID
Add more API keys to increase capacity	Coordinate the account's callers
Automatically switch to a paid model when blocked	Make paid fallback an explicit, budgeted policy

Adding balance raises the free route's documented frequency allowance; it does not automatically change the request's model. Paid calls require an explicit switch to deepseek-v4.1-flash and are billed separately. Keep that decision visible in configuration.

Free DeepSeek API FAQ

Is free DeepSeek V4.1 Flash unlimited?

No. Free token pricing and request frequency are different properties. The route also depends on continued availability.

Does the free DeepSeek API need a top-up?

The free route is intended to work without an initial top-up. Use a BeatAPI key in the default auto group and the exact free model ID.

Does HTTP 429 mean I need to buy credits?

It indicates a rate-policy block. Inspect the response and current account conditions before deciding what to change. Immediate payment is not a substitute for a scheduler.

Can a free DeepSeek API run a scheduled task?

Small tasks that tolerate waiting can fit the route. Your scheduling, hosting, and storage may have their own costs, and the free route may change.

Will a timeout retry duplicate a request?

Possibly. The server may have completed work before the client timed out. Do not assume a universal idempotency guarantee; preserve input IDs and avoid repeating downstream writes.

Where can I check free DeepSeek API access and limits?

Use the DeepSeek API page, the public price book, and its linked documentation. Start with one small request, then decide whether the queue's waiting time fits your task.

Disclosure: I work on BeatAPI. This is a workflow design and request example, not a live performance benchmark.

Where Can I Get a Free JEV API for n8n Text Classification?

Eric Kang — Fri, 02 Oct 2026 10:34:46 +0000

Where can I get a free JEV API?

For n8n text classification with a fixed set of labels, call BeatAPI's free JEV API through an HTTP Request node, read the typed answer, and pass a validated label to a Switch node. The free model is jev-1.13-free; input and output cost $0, including at a zero balance. You do not need a text-generating agent to write a category as prose.

Define category names before sending the request.
Use POST https://api.beatapi.io/v1/systemone with a BeatAPI key.
Read the response's answers, rather than parsing a generated paragraph.
Route malformed or uncertain decisions to a review branch.
Keep input IDs alongside decisions and pace calls within the account limit.

The free JEV API page is the setup destination. The existing JEV decision-layer guide explains its broader agent use cases; this tutorial concentrates on wiring a classifier into n8n.

Free JEV API access: key, endpoint, and model

Question	BeatAPI route
Where do I get the key?	Dashboard → API keys, default `auto` group
Which model is free?	`jev-1.13-free`
Endpoint	`POST https://api.beatapi.io/v1/systemone`
Request fields	`model`, `state`, `questions`
Output	Named typed decisions under `answers`
Initial account limit	One successful call per minute
After any top-up	Up to ten successful calls per minute; no automatic model switch

The free JEV API on BeatAPI uses a BeatAPI key. Do not paste a key from another service into this endpoint or assume a third-party community node accepts it. The built-in HTTP Request path below makes every connection setting visible.

The free JEV API is useful when the answer belongs to a predefined set. Its value here is a bounded classification response you can validate, rather than a promise that all automation should use a decision model.

Which free JEV API offer actually fits your workflow?

The following distinction was checked on October 2, 2026. Free JEV API access on BeatAPI means a reusable key and the explicitly selected free model, subject to the limits above. Other access routes have different conditions:

Route	What its public source establishes	Practical difference
TypeSafe direct	TypeSafe key, `https://api.typesafe.ai/v1/systemone`, `jev-latest`	Separate credentials; the quickstart does not establish a recurring free allowance
OpenRouter JEV	$0.042 per million input tokens, $0 output	Free output alone does not make the request free
n8n Cloud promotion	Eligible Cloud plans can use JEV via Gateway credits until October 10, 2026, 23:59 UTC without consuming credits	In-product promotion, not a reusable external API key; normal Gateway rates apply afterward
Vercel Academy promotion	The stated free period ended September 25, 2026	An older tutorial is not evidence of a current free offer

Choose the free JEV API route by the requirement: a reusable external key, built-in access within an existing subscription, or higher paid throughput. Check current terms instead of carrying an expired promotion into your configuration.

What the free JEV API changes in a classifier

In an n8n community question, a user running a text-classification template received a parsing error because the model returned Markdown-wrapped content instead of the expected JSON. Their report concerned a local model and n8n 1.72.1. It illustrates a failure mode, rather than proving that current n8n classifiers are broken.

If the task is “choose one of these categories,” your application already knows the legal output set. A typed decision API avoids asking a generative model to reproduce that set in a correctly formatted paragraph. You still parse the HTTP response as JSON and validate its fields; what disappears is the extra step of interpreting generated text as a second JSON document.

Use a generative model when you need a summary, explanation, or reply. Use deterministic rules when an exact keyword or field decides the outcome. JEV is useful for the fuzzy classification between those two cases.

Design a small free JEV API classification workflow

This worked example sorts release notes into three categories:

Category ID	Definition	Next step
`feature`	Adds a new user-facing capability	Product-update draft queue
`fix`	Corrects an existing failure	Fix-note draft queue
`other`	Does not clearly fit either category	General review queue

The workflow is:

Manual Trigger → sample records → HTTP Request → validate answer → Switch
                                                    ↓
                                              review on uncertainty

Start with a Manual Trigger and one synthetic record: id: note-001, text: Fixed duplicate rows in CSV downloads. There is no need to connect a production mailbox or send messages while proving the classifier.

Category IDs should stay stable even when you translate the displayed labels. Those IDs become Switch conditions, stored results, and evaluation labels.

Configure the free JEV API request in n8n

In the HTTP Request node, configure:

Setting	Value
Method	`POST`
URL	`https://api.beatapi.io/v1/systemone`
Authentication	Header Auth credential
Credential header	`Authorization: Bearer YOUR_BEATAPI_KEY`
Body type	JSON
Response format	JSON

Store the key in an n8n credential. Keep the BeatAPI key's group at auto. JEV is not a Chat Completions model, so an OpenAI Chat Model node is not the request surface for this example.

For the first manual test, send this fixed body:

{
  "model": "jev-1.13-free",
  "state": {
    "id": "note-001",
    "text": "Fixed duplicate rows in CSV downloads."
  },
  "questions": {
    "category": {
      "type": "choice",
      "instructions": "Classify this release note by its main user-visible change.",
      "criteria": {
        "feature": "Adds a new user-facing capability.",
        "fix": "Corrects a failure in an existing capability.",
        "other": "Does not clearly fit feature or fix."
      }
    }
  }
}

Then change the whole JSON body to an n8n expression that returns an object:

{{ ({
  model: 'jev-1.13-free',
  state: { id: $json.id, text: $json.text },
  questions: {
    category: {
      type: 'choice',
      instructions: 'Classify this release note by its main user-visible change.',
      criteria: {
        feature: 'Adds a new user-facing capability.',
        fix: 'Corrects a failure in an existing capability.',
        other: 'Does not clearly fit feature or fix.'
      }
    }
  }
}) }}

This expression avoids constructing JSON by interpolating text inside quotation marks. Inspect the outgoing body to ensure it contains the input record, not the literal characters $json.text. The setup is a contract-based example; it has not been executed against a live n8n workspace in this guide.

Validate a free JEV API answer before branching

The Decisions API documentation describes named answers under answers. For a Choice question, read the choice, category probabilities, and confidence. The following is a synthetic fixture for testing your mapping, not a measured model result:

{
  "answers": {
    "category": {
      "type": "choice",
      "choice": "fix",
      "probabilities": { "feature": 0.03, "fix": 0.95, "other": 0.02 },
      "confidence": 0.94
    }
  }
}

In a Code node with Mode set to Run Once for Each Item, validate and normalize the decision:

const answer = $json.answers?.category;
const allowed = ['feature', 'fix', 'other'];
const labelValid = answer?.type === 'choice' && allowed.includes(answer.choice);
const confidenceValid = Number.isFinite(answer?.confidence)
  && answer.confidence >= 0 && answer.confidence <= 1;
const probabilities = allowed.map(label => answer?.probabilities?.[label]);
const distributionValid = probabilities.every(p => Number.isFinite(p) && p >= 0 && p <= 1)
  && Math.abs(probabilities.reduce((sum, p) => sum + p, 0) - 1) < 0.01;
const valid = labelValid && confidenceValid && distributionValid;
const threshold = 0.8; // Illustrative starting policy; evaluate before operational use.

return { json: {
  request_id: $json.id ?? null,
  category: valid ? answer.choice : null,
  confidence: valid ? answer.confidence : null,
  route: valid && answer.confidence >= threshold ? answer.choice : 'review'
} };

If you enable full-response output in the HTTP Request node, the payload may be under body; update the mapping accordingly. Do not quietly turn a missing answer into an accepted category.

Configure Switch branches for feature, fix, other, and review, using the normalized route. Keep the default branch connected to review too. Review indicates uncertainty or invalid data; other is an intentional category.

Preserve free JEV API input records and evaluate the threshold

The response's id is an API request identifier, not the input record ID. Preserve your original note-001 separately using n8n item linking or a Merge step. When retries or concurrent branches are introduced, do not match outputs by array position alone.

Before automating downstream work, hand-label a small set containing straightforward features, obvious fixes, mixed notes, and insufficient context. Compare predicted categories with your labels. Review both wrong high-confidence results and correctly rejected ambiguous cases.

The 0.8 threshold in the code is a demonstration policy. It does not mean 80% real-world accuracy and is not a verified threshold for your data. Raise, lower, or replace it based on your evaluation and the cost of a wrong branch. Keep the first run connected to draft queues or logs.

Free JEV API limits: pace your n8n workflow

The free JEV API allows one successful call per minute per account before the first top-up, and up to ten afterward. Use a paced, small test set. Coordinate overlapping executions because multiple keys still share the account limit. For 429, honor the documented Retry-After header and bound retries.

These limits make the free route useful for learning and small experiments. They do not establish that a large inbound queue can run continuously for free. Any top-up leaves the free model free; paid usage requires explicitly selecting jev-1.13.

Free JEV API FAQ

Can I use the free JEV API without a community node?

Yes, this example uses the built-in HTTP Request, Code, and Switch nodes. It does not assume a third-party node supports BeatAPI credentials or its endpoint.

Does this remove all JSON parsing?

No. n8n still decodes the API response. It avoids parsing model-generated prose or Markdown into a separate JSON object.

Is JEV an API for generating emails?

No. This request chooses a category. A separate text model can write a draft after the workflow has validated the branch.

Does the free JEV API work with no balance?

The documented jev-1.13-free route supports a zero balance with an auto group key. Check the free JEV API page for current conditions.

Should I route every answer to its highest-probability label?

No. Retain a review path for uncertainty, invalid answers, and unsupported input. A probability signal is not permission for a consequential action.

Does the old community parsing error prove a current n8n bug?

No. It is a historical user problem that motivates the design. Validate the current n8n version and your actual workflow before deploying it.

Disclosure: I work on BeatAPI. The examples are based on its public API contract; the JEV response values are synthetic fixtures, and the n8n workflow has not been run live for this article.

How to Use Space Bunny Alpha for Coding: Setup, Tests, and Free Limits

Eric Kang — Wed, 30 Sep 2026 11:13:49 +0000

Related integration page and current specifications: BeatAPI

To learn how to use Space Bunny Alpha for coding, choose a hosted API or a client such as OpenCode, then test one small repair. It is currently available as a free-preview coding model. Choose the access route first: BeatAPI uses space-bunny-alpha, OpenRouter uses stealth/space-bunny-alpha, and OpenCode Zen lists space-bunny-free. A key, model ID, and base URL from different services will not form a valid configuration.

This guide takes you from model selection to a small, verifiable code-repair task. It also explains slow or verbose output, rate limits, capacity failures, and what to do if the preview disappears. Documentation was checked on September 30, 2026. The API and client examples are documentation-based; we have not executed authenticated model calls for this guide.

Free currently means zero model token price, not guaranteed permanent access or unlimited capacity.
Start with a small task and an explicit test; avoid judging the model by a long explanation.
On BeatAPI, reasoning_effort defaults to max. Evaluate low for a simple repair.
Handle 429 and temporary 503 separately, and cap retries.
Keep a named fallback and require approval before a free workflow incurs paid usage.

How to use Space Bunny Alpha: choose one route

Route	Model ID	API base URL	What to verify
BeatAPI	`space-bunny-alpha`	`https://api.beatapi.io/v1`	Free-model request limits and current account availability.
OpenRouter	`stealth/space-bunny-alpha`	`https://openrouter.ai/api/v1`	Account limits, preview terms, and route-specific data policy.
OpenCode Zen	`space-bunny-free`	`https://opencode.ai/zen/v1`	Current model listing, signup conditions, and limited-time access.

Sources: BeatAPI's model documentation, OpenRouter's listing, and OpenCode Zen documentation. Do not transfer a parameter name, quota, or privacy promise from one route to another without checking it.

The model's maker remains officially unidentified in the listing. Its advertised 1M context and multimodal input do not establish that it is a particular announced model or that it produces images or video. For the background and identity evidence, read What Is Space Bunny?; this article focuses on completing a coding task.

Start in OpenCode

If you already use OpenCode, open it in a small test repository. Run /connect, choose OpenCode Zen, and follow its account connection steps. Then run /models and choose Space Bunny Free. The route's model ID is space-bunny-free; within OpenCode's provider/model syntax the selection is:

opencode -m opencode/space-bunny-free

If the model is missing, update OpenCode and refresh the model list before changing your credentials or inventing an alias:

opencode upgrade
opencode models --refresh

These commands and provider/model conventions follow the CLI reference and model configuration guide. Availability can change during the preview, so a missing listing may be real rather than a local cache problem.

For OpenRouter inside OpenCode, connect to OpenRouter using its key and choose the corresponding listing instead. The model selection is openrouter/stealth/space-bunny-alpha. That is an OpenCode selection string; the direct OpenRouter API request still uses stealth/space-bunny-alpha.

Free token pricing does not establish that every account can be opened without funding or that auxiliary models used by a coding client are also free. Inspect signup conditions, title-generation models, and automatic top-ups separately before running unattended work.

Call the BeatAPI endpoint directly

For a minimal Python example, install the OpenAI SDK and set BEATAPI_API_KEY in your environment. The key is sent only to BeatAPI's endpoint.

python -m pip install --upgrade openai

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BEATAPI_API_KEY"],
    base_url="https://api.beatapi.io/v1",
    timeout=180.0,
    max_retries=0,
)
completion = client.chat.completions.create(
    model="space-bunny-alpha",
    reasoning_effort="low",
    max_tokens=8192,
    messages=[{
        role: "user",
        content: (
            "Review this function for a missing final chunk:\n"
            "def chunk(items, size):\n"
            "    return [items[i:i+size] "
            "for i in range(0, len(items)-size, size)]\n"
            "Assume size must be a positive integer. "
            "Return the corrected function and three tests. "
            "Keep the explanation under 100 words."
        ),
    }],
)
choice = completion.choices[0]
print("finish_reason:", choice.finish_reason)
print(choice.message.content)
if completion.usage is not None:
    print(completion.usage.model_dump())

The model ID, endpoint, reasoning setting, and rate-limit behavior follow BeatAPI's public contract. The SDK's retries are disabled here so that a test does not silently multiply requests; your application can add a bounded policy after inspecting actual errors. If finish_reason indicates truncation, do not treat the partial function as finished.

Use the Space Bunny Alpha integration page for the current setup and limits. The request asks for code as text; it does not grant access to your repository or run tests automatically.

A code-repair task with a clear acceptance check

The buggy loop stops before the final starting position. For five items and a chunk size of two, it returns only the first four items; for exactly two items and a size of two, it returns no chunks at all. A valid implementation should start slices through the full input and reject a non-positive size.

Use this as the acceptance specification, written before requesting a patch:

def verify(chunk):
    assert chunk([1, 2, 3, 4, 5], 2) == [[1, 2], [3, 4], [5]]
    assert chunk([1, 2], 2) == [[1, 2]]
    assert chunk([], 2) == []
    for size in (0, -1):
        try:
            chunk([1], size)
        except ValueError:
            pass
        else:
            raise AssertionError("non-positive size must raise ValueError")

A reference implementation for the declared positive-integer contract is:

def chunk(items, size):
    if size <= 0:
        raise ValueError("size must be positive")
    return [items[i:i + size] for i in range(0, len(items), size)]

verify(chunk)

The reference and acceptance checks were run locally. They establish the exercise's expected behavior; they are not a Space Bunny-generated result. When you run the model example, execute the tests against its returned patch and inspect the diff. If it changes the tests to hide a failure, reject that attempt.

In OpenCode, use a task prompt that includes the same criteria:

Fix only chunk.py so it preserves the final partial chunk and rejects
non-positive chunk sizes. Do not edit the tests or add dependencies.
Run the existing tests. Return the patch, the actual test result, and a
summary under 100 words. If a tool fails, report the failure instead of
claiming that the tests passed.

This exercise is deliberately small. It separates model correctness, client tool execution, and explanatory verbosity without giving an anonymous preview unrestricted production work.

Why does it think so much or answer too long?

A Kilo user report describes useful routine coding results alongside very verbose answers. That is firsthand experience, not a controlled benchmark, but it identifies a practical configuration question.

On BeatAPI, reasoning is always enabled and the documented default effort is max. For a simple repair, compare low with the default while holding the task and acceptance checks constant. Lower effort may reduce latency, but does not guarantee an equivalent result. A concise output instruction controls what you request in the answer; it does not turn internal reasoning off.

Limit the task scope, give the failing test, exclude unrelated files, and specify the final format. Record elapsed time, finish reason, tests passed, and returned token usage. A short-looking answer can still involve substantial reasoning; a long answer can still contain a wrong patch.

Free limits, errors, and fallback behavior

BeatAPI currently documents 1 successful free-model request per minute before a first top-up, and at most 10 requests per minute after any top-up, independent of the amount paid. Free calls have their own allowance. Funding the account changes that documented request limit; it does not buy a stronger Space Bunny model or establish a concurrent-request guarantee.

Symptom	Next step
`401`	Check which service issued the key and which endpoint you called.
Model missing or unavailable	Inspect the current account model list; verify the exact route's ID.
`429` on BeatAPI	Respect `Retry-After`, then retry within a bounded attempt limit.
`503 processing_unavailable`	Temporary capacity can fail even below your request limit; wait briefly, cap retries, then surface the failure.
Truncated or empty final output	Inspect finish reason and budget before retrying the task.
Plausible patch, failing tests	Return the actual failure to the agent; stop after the turn cap.

Use GET /v1/models to check availability before depending on the preview. Do not reroute a limited free request to a paid model silently. A fallback policy should name the alternative, maximum budget, and the action requiring approval. For example: after two temporary failures, offer to run the task with a named paid model at a capped budget, or let the user wait.

Frequently asked questions

Is Space Bunny permanently free?

No permanence is promised. OpenCode calls it limited-time, and anonymous previews can be withdrawn. Build the application so the model is replaceable.

Is it MiniMax M3.1 or another named model?

Its developer is not officially identified in the listing. Similar behavior or tokenizer clues do not establish a confirmed model version.

Can I use the same ID everywhere?

No. Use the route table above. The OpenCode provider prefix is also different from a raw API model ID.

Does a top-up make it smarter?

BeatAPI's published change concerns request limits. It is not a quality upgrade to the model.

Is confidential code safe to send?

Review the exact access route's current data terms. OpenCode's model-specific zero-retention wording and OpenRouter's retention wording are different. A promise on one route does not apply to another; start the exercise with public or synthetic code.

What should I do after the first successful task?

Repeat on a few small tasks with known checks, then record correctness, retries, and latency. Use the integration guide for configuration and the model overview for current capability context before adopting it in a larger workflow.

If you decide to evaluate a paid alternative, the GPT-6.1 Sol integration guide provides a separate setup and cost worksheet.

Disclosure: We build BeatAPI. This article distinguishes documentation-based examples from tests actually executed; it does not report a model benchmark.

GPT-6.1 Sol vs GPT-6 Sol vs Astra: Costs and Migration for Coding Agents

Eric Kang — Wed, 30 Sep 2026 11:11:35 +0000

Related integration page and current specifications: BeatAPI

For GPT-6.1 Sol vs GPT-6 Sol vs Astra, start with compatibility and complete-task cost. For a Responses-based coding agent, evaluate GPT-6.1 Sol as the next default; retain GPT-6 Sol when an existing integration depends on disabled reasoning, and use GPT-6 Astra when it produces enough additional correct work to justify the premium. This is a selection framework, not a claim that we ran a three-model benchmark.

The most useful comparison is not just intelligence versus token price. It is whether your agent remains compatible, what its complete task costs, and whether the resulting patch passes your acceptance tests. Specifications and Standard prices below were checked on September 30, 2026.

Old Sol and 6.1 Sol have the same Standard input, write, and output prices.
The new model halves the cache-read rate, not every task's bill.
6.1 Sol and Astra require Responses for tools and do not support none reasoning.
Compare success, retries, total usage, and latency with the same task and harness.
Keep a verified escalation path instead of routing every task to the most expensive model.

GPT-6.1 Sol vs GPT-6 Sol vs Astra at a glance

Decision point	GPT-6 Sol	GPT-6.1 Sol	GPT-6 Astra
API ID	`gpt-6-sol`	`gpt-6.1-sol`	`gpt-6-astra`
OpenAI input / output per million	$2 / $10	$2 / $10	$10 / $50
Cached input per million	$0.20	$0.10	$1.00
Cache write per million	$2.50	$2.50	$12.50
Context / maximum output	1,050,000 / 128,000	1,050,000 / 128,000	1,050,000 / 128,000
Disabled reasoning	`none` supported	Unsupported	Unsupported
Tool calls through Responses	Supported	Supported	Supported
Tool calls through Chat Completions	Only with `none`	Unsupported	Unsupported

These are OpenAI direct Standard rates and documented endpoint capabilities, not a guarantee of feature parity at another gateway. Sources: GPT-6 Sol, GPT-6.1 Sol, GPT-6 Astra, and the migration guide.

OpenAI positions the new Sol close to Astra for complex coding, computer use, and professional work. That makes it worth testing before paying Astra rates for every turn. It does not establish a universal winner for writing, repository review, or difficult debugging. If you are new to the model, start with what GPT-6.1 Sol is and how to call it.

Is the new Sol actually cheaper?

At equal token counts, the changed Standard rate relative to old Sol is cached input: $0.20 becomes $0.10 per million. If there are no cache reads, the listed token rates produce the same bill. If reasoning changes, retries change, or the model writes longer answers, equal rates do not imply equal spending.

Take a declared short-context workload, not an executed benchmark: 100,000 uncached input tokens, 900,000 cache reads, and 50,000 total output tokens, distributed across requests that each stay below the long-context threshold. There are no cache writes or paid tools in this fixture.

Model	Uncached input	Cache reads	Output	Total
GPT-6 Sol	$0.200	$0.180	$0.500	$0.880
GPT-6.1 Sol	$0.200	$0.090	$0.500	$0.790
GPT-6 Astra	$1.000	$0.900	$2.500	$4.400

The new Sol saves approximately 10.2% against old Sol on this ledger. It is approximately 82.0% cheaper than Astra for these same counts. Neither percentage predicts task-level savings if the models consume different amounts of reasoning or require different numbers of attempts.

For an actual decision, replace the fixture with returned usage. Count all attempts, including failed patches and retries. Do not infer API spend from a ChatGPT or Codex subscription's percentage meter. A first-person cost discussion illustrates why that distinction confuses users; the post's generated estimates are not billing evidence.

For longer loops, the Astra coding-agent cost worksheet explains repeated context. Its dated service-specific rates should be rechecked before reuse.

The migration boundary: tools and disabled reasoning

Suppose your old request combines these fields:

{
  model: "gpt-6-sol",
  reasoning_effort: "none",
  tools: [
    {
      type: "function",
      function: {
        name: "run_tests",
        description: "Run the isolated project's tests.",
        parameters: {"type": "object", "properties": {}, "required": []}
      }
    }
  ]
}

Changing only model to gpt-6.1-sol leaves two problems: disabled reasoning is unsupported, and tool calling belongs on Responses. A migrated request uses the Responses tool shape and a supported effort:

{
  model: "gpt-6.1-sol",
  reasoning: {"effort": "low"},
  input: "Run the tests and explain the first failure. Do not edit files yet.",
  tools: [
    {
      type: "function",
      name: "run_tests",
      description: "Run the isolated project's tests.",
      parameters: {
        type: "object",
        properties: {},
        required: [],
        "additionalProperties": false
      },
      strict: true
    }
  ]
}

Send it to your selected service's /v1/responses. These snippets demonstrate request shapes, not a complete agent or an authenticated test. Your application must inspect the typed output, execute an authorized function, and return function_call_output with the matching call_id. A schema named run_tests cannot run your tests by itself. Function calling documentation

Before switching, verify a complete round trip: first tool request, real test execution, returned result, and final answer. Preserve necessary reasoning and tool items when managing history. Recheck sampling fields such as temperature and top_p against the migration guide; an adapter can inject unsupported defaults even if your visible request does not.

A fair coding-agent comparison you can reproduce

Use a small repository with a known failing test. For example, a chunk function using range(0, len(items) - size, size) loses the final chunk and fails when the input length equals the chunk size. Ask each model to diagnose and fix it without changing the tests.

Keep the same repository commit, tool permissions, prompt, test suite, turn cap, and output budget. Record the reasoning effort instead of treating each model's default as equivalent. Run more than one attempt if you want to discuss consistency.

Record	Why it matters
Tests passed and patch diff	Plausible explanations do not establish correctness.
Attempts and tool calls	A cheaper call may require more iterations.
Uncached, cached, write, and output usage	Visible answer length hides reasoning and repeated input.
Elapsed time and failures	A fast answer is not always a fast completed task.
Accepted result and total charge	Measures cost per useful outcome.

We have not run this controlled model experiment. It is the evaluation procedure to use before claiming that one model is faster, smarter, or cheaper per completed task. An arithmetic rate comparison and a vendor evaluation do not substitute for it.

When should you choose each model?

Evaluate 6.1 Sol first for a new Responses-based coding agent or an existing Sol workflow that already uses supported reasoning. Its pricing makes it a reasonable candidate for everyday implementation, review, and repository analysis, subject to your acceptance checks.

Keep old Sol while migrating if your production agent depends on none or Chat Completions tool calling. First make the endpoint and parsing changes on an isolated task; then compare behavior. Keeping a working model during a controlled migration is preferable to changing all components at once.

Escalate to Astra when a representative failure analysis shows that it produces more correct accepted results on a particular class of difficult work. Supply a compact summary, failed approaches, and the test evidence rather than blindly replaying an enormous transcript. Escalation should have a turn cap and spend cap.

For a simple budget rule, compare total cost divided by accepted tasks over the same test set, while also tracking latency. That includes failed attempts. Avoid declaring an Astra task “worth it” merely because the answer sounds more sophisticated.

Long context and access-route caveats

All three official model pages apply higher rates to an entire request once input exceeds 272K tokens: input and cache rates double, output rates multiply by 1.5. Sending a 1M-token repository is therefore a different budget decision from using a 100K-token working context. A larger maximum window is not a reason to include every file.

If you choose BeatAPI, inspect 6.1 Sol, old Sol, and Astra individually. Use those customer rates to recalculate the ledger, and verify your required tools. OpenAI direct service tiers, hosted tools, residency controls, and account terms are not implied by a gateway's compatible request format.

Frequently asked questions

Is switching from Sol to 6.1 Sol just a model-name change?

Only some compatible requests can be that simple. Audit reasoning settings, tools, sampling parameters, response parsing, and continuation handling first.

Is 6.1 Sol half the price of old Sol?

The cache-read rate is half. The other Standard token rates in this comparison are unchanged. Overall savings depend on actual usage and behavior.

Is Astra always five times more expensive?

Its ordinary input, output, and cache-write Standard rates are five times the new Sol's; cached reads are ten times. Task-level cost also depends on token counts, attempts, processing mode, and tools.

Which reasoning setting should I compare?

Preserve an existing supported effort initially. When replacing none or minimal, evaluate low. Record settings and compare actual outcomes rather than assuming equal effort names ensure equal computation.

Should every failed Sol task go to Astra?

No. Fix missing context, broken tools, or ambiguous acceptance criteria first. Escalation helps only when model capability is the likely limiting factor.

Where should a new user start?

Use the 6.1 Sol first-request guide, then evaluate one bounded tool task before adopting a default or escalation policy.

Disclosure: We build BeatAPI. This article distinguishes documentation-based examples from tests actually executed; it does not report a model benchmark.

Calling Space Bunny: A First API Request and an Exit Plan

Eric Kang — Tue, 29 Sep 2026 04:24:29 +0000

Space Bunny is useful precisely because it is easy to try: a free, 1M-context model with text, image, and video input. It is also a poor model ID to hardcode into a production app. The developer is still anonymous, and neither public route promises when the free preview ends.

This is a practical companion to our Space Bunny builder's guide. It focuses on the first request, what to measure, and how to make the eventual switch boring. This is not a benchmark or a claim that we ran the prompts below.

Check the route before you call it

As of September 29, 2026, the two published routes are:

Route	Model ID	What the listing says
OpenRouter	`stealth/space-bunny-alpha`	Free, 1M-token context, text/image/video input, text output, adjustable reasoning effort
OpenCode Zen	`space-bunny-free` (`opencode/space-bunny-free` in OpenCode config)	Free model in Zen's OpenAI-compatible chat-completions endpoint

Both require an API key from the route you choose. Their data terms are different: OpenRouter says the anonymous third-party provider may retain prompts and completions but does not use them for training. OpenCode publishes its own Zen privacy policy and exceptions. Read the current terms before sending private code or customer data. A listing also does not guarantee that a request will succeed at any particular moment.

Make one small request

For OpenRouter, put your own key in OPENROUTER_API_KEY and send a low-stakes prompt:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "stealth/space-bunny-alpha",
    "reasoning": { "effort": "low" },
    "messages": [
      { "role": "user", "content": "Summarize this public changelog in five bullets: ..." }
    ]
  }'
~~~{% endraw %}

For OpenCode Zen, use its own key and model ID at {% raw %}`https://opencode.ai/zen/v1/chat/completions`{% endraw %}. You cannot swap the two keys. In OpenCode's configuration, the model ID takes the {% raw %}`opencode/` prefix; in the direct Zen API request, the model ID is `space-bunny-free`.

Start with public, non-sensitive material. Check the returned model, response text, usage, latency, and any error before putting this into an agent loop. OpenRouter lists tool calling and JSON output support, but a feature flag is only a reason to test those paths, not a reliability guarantee.

## Build a tiny evaluation set before the preview disappears

The 1M context window makes Space Bunny interesting for repository navigation, long documents, and agent sessions. A single impressive demo will not tell you whether it works for *your* workload. A repeatable check is more useful:

1. Save 15–30 prompts from work you actually do, with a note about what a good answer must contain.
2. Include short, long-context, image, and tool-use cases only if your product uses them.
3. Run the same prompts through Space Bunny and two named models you would be willing to pay for.
4. Record output quality, source fidelity, latency, reasoning-token use, tool-call errors, and timeouts. Keep the full prompt and route with each result.
5. Re-run the set when the model ID, provider, price, or data terms change.

If you want examples of **publicly reported** Space Bunny tests and their limitations, see our separate [Hugging Face case roundup](https://huggingface.co/blog/karmen-beatapi/space-bunny-tested-real-cases-evaluation). We did not run those third-party tests ourselves.

## Keep an exit door in the code

Use one configuration value for the primary model and one for a named fallback:

~~~js
export const models = {
  primary: process.env.PRIMARY_MODEL ?? 'stealth/space-bunny-alpha',
  fallback: process.env.FALLBACK_MODEL ?? 'your-named-baseline',
};
~~~

Then decide the switch rule *now*: for example, move to the cheapest named model that stays within an acceptable quality gap on your own evaluation set when Space Bunny stops being free or its route becomes unreliable. Recheck pricing at that time; do not assume today's $0 listing will persist.

The full [Space Bunny builder's guide](https://spacebunny.im/blog/what-is-space-bunny/) keeps the route comparison, setup details, source links, and five-step exit plan in one place. It is an independent guide, not the model's official site.

*Disclosure: We publish spacebunny.im and also work on BeatAPI. BeatAPI does not provide Space Bunny access as of September 29, 2026. The model IDs and pricing above come from the linked OpenRouter and OpenCode listings, not from our own provider.*

JEV is blowing up. 13,000+ repos on GitHub — these 228 are the ones you actually need to see.

Eric Kang — Mon, 28 Sep 2026 07:26:28 +0000

What open-source JEV integrations have in common, and which file to open first.

Search GitHub for "jev" today (28 September 2026) and you get 13,473 repositories. That is a search total, not a count of JEV projects. Some are unrelated names. Many mention JEV in a README and never call it.

From the ones that actually use JEV, we hand-picked 228: repositories where you can open one file and see the exact line where JEV makes a decision.

That list is Awesome JEV: 228 projects in 10 types, every entry pinned to a fixed commit.

How we picked

We did not read all 13,473. We selected 228 relevant projects ourselves. Each candidate then had to clear three bars:

50+ GitHub stars
A JEV decision we could open in the source, not a name in the README
A fixed commit, so the file you open is the file we read

Two limits, stated up front. Every entry is source-reviewed; none were independently run by us. And stars belong to the whole repository: LangChain's 146.9K stars are not stars for its JEV classifier.

What 228 integrations have in common

1. JEV picks. Your code acts.

Open Jev Ultrafast (18.2K stars), a browser agent. The code builds the list of legal moves from the page: click, type, select, plus two exits, DONE and BLOCKED. JEV picks one operation and one target from that list. Before anything happens, the answer is validated. The choice has to be in the list, and the probabilities have to sum to 1. If the check fails, the code raises "no action executed." A text model is called only when a field actually needs typing.

Open LiteLLM's JEV router (59.4K stars). It sends one choice question named tier, instructed to "pick the cheapest tier whose models can fully answer this request." The router config decides what each tier means.

The same shape keeps coming back:

QuantDinger (12.0K) checks evidence, exposure and budget before an order reaches the exchange.
Agentgateway (5.0K) scores jailbreak and secret-leak risk before gateway policy accepts a request.
OpenViking (38.5K) asks one relevance question per retrieved memory and falls back to vector scores when evaluation fails.
Skillranker abstains when confidence is below policy.

The reusable unit is not "an agent that uses JEV." It is a closed list your code wrote, one typed answer, and a rule for what happens when that answer is weak.

2. The request format is spreading faster than the model

31 of the 228 are open-model projects. At least 9 of them keep JEV's request format: state plus named Noul, Choice and Score questions, often on the same /v1/systemone path. They swap the model underneath: LocalJev, Jeff, jevmlx, Laya Server and OpenJEV SGLang among them. Several say plainly that they do not reproduce JEV itself.

Laya (17.1K stars) publishes its weights on Hugging Face and answers typed questions in one forward pass.

In practice, code written against the question format has more than one place to run. Several of these projects are built on that assumption.

3. The stars sit in host repos. The ideas sit in the long tail.

The median entry has 251 stars. 151 of the 228 have fewer than 500. Only 20 pass 10K, and most of those are large hosts that added JEV as one option: LangChain, LiteLLM, AI Hedge Fund (63.7K), Composio.

The stranger ideas are small: a Mario agent that picks only legal moves (355 stars), a drone that chooses maneuvers from range sectors (134), a YouTube extension that skips sponsor reads (91), Postgres functions that turn a JEV judgment into a SQL condition (314).

Sort by stars and you find adapters. The patterns are further down.

4. There are already 20 JEV directories

20 of the 228 entries are other JEV lists with 50+ stars each. We are one more, so we did not want to publish another list of links. Every entry here states what JEV is asked to decide and links to the commit where that happens.

Six jobs, one file each

Filter a live page: Jev Ultrafast → jev_ultrafast/model.py
Route to a model: LiteLLM JEV Router → jev_classifier.py
Plug into a framework: LangChain TypeSafe (binary, categorical and ordered-score questions) → classifier.py
Run it locally: Laya → weights on Hugging Face, plus a checkpoint router
Gate a request: Agentgateway → guardrail.ts
Filter before the large model writes: NewsJack. JEV scores hundreds of headlines, and the agent expands only the short list. → demos/news-desk-dealer

The repo also has six scenario guides (filter content, find documents, choose a model, review output, operate an interface, trim context), each listing nearby projects and the part worth copying.

Ask your agent instead of searching

Searching the catalogue needs no API key. Paste this into Codex, Claude Code or OpenCode:

Install the Awesome JEV skill from BeatAPI/awesome-jev.
Then find projects for my task, and point to the exact file worth reading.
Do not call any paid API.

Or install it yourself:

npx skills add BeatAPI/awesome-jev

Then ask: "I want to filter news with JEV. Find 3 reference projects and name the file in each one worth copying."

Catalogue: Awesome JEV on GitHub
Browse and filter all 228: Awesome JEV on BeatAPI

Source-reviewed at fixed commits, not independently run. Star counts were captured on 28 September 2026 and belong to whole repositories.

What Is Space Bunny? The Anonymous 1M-Context Model, Explained

Eric Kang — Mon, 28 Sep 2026 03:14:27 +0000

Originally published on BeatAPI. Facts in the source article were checked on September 27, 2026. OpenRouter still listed Space Bunny Alpha as an anonymous, free preview on September 28.

TL;DR

What it is: an anonymous "stealth" AI model. OpenRouter lists it as Space Bunny Alpha (stealth/space-bunny-alpha) and OpenCode as Space Bunny Free (space-bunny-free). Both listings went live on September 23, 2026.
Verified specs: a 1M-token context window, up to 524,288 output tokens, text, image, and video input with text output, mandatory reasoning with five effort levels, tool calling, and $0 pricing during the preview.
Who built it: officially, nobody has said. Two independent tokenizer studies put it in the MiniMax family. That's strong evidence for the family, not for a specific model version.
The M3.1 question: MiniMax announced M3.1-Flash-Preview inside its MiniMax Code product on September 27 but hasn't connected it to Space Bunny. "Space Bunny is M3.1" is still speculation.
Want test results instead of background? Our Hugging Face companion post, "Space Bunny Tested: Real Cases and How to Evaluate a Stealth Model," collects the public test cases and a reusable evaluation plan.

The short answer

Space Bunny is a preview model released under a codename. The developer runs it, gateways route traffic to it, and nobody publicly takes credit until an official launch. OpenRouter states that the model "is developed and operated by a third-party provider who has chosen to remain anonymous during this preview," and that OpenRouter "is not its developer, owner, or provider."

In OpenRouter's launch post on X, the company described it as "a flash model with fast inference, adjustable reasoning, and a 1M-token context window." "Flash" is the important word. This is pitched as a fast, low-cost tier, not a flagship, and community comparisons have treated it that way. It usually gets tested against DeepSeek V4.1 Flash and GLM 5.3 Flash, not the largest frontier models.

Specs and access at a glance

We took these from OpenRouter's public models API, OpenCode's Zen documentation, and the models.dev catalog on September 27, 2026.

	OpenRouter	OpenCode (Zen and Go)
Name and ID	Space Bunny Alpha, stealth/space-bunny-alpha	Space Bunny Free, space-bunny-free
Listed	Sep 23, 2026, 14:48 UTC	Sep 23, 2026
Context / max output	1,000,000 / 524,288 tokens	1,048,576 / 524,288 tokens
Modalities	Text, image, video in; text out	Text, image, video in; text out
Reasoning	Always on; low, medium, high, xhigh, max; default max	Low through max
Price	$0 / $0 per million tokens	Free for a limited time
Data terms	Provider may retain prompts and completions; not used for training	Zero retention; no training use

The model also shows up in Kilo's catalog at no cost. The "tokenizer" field on OpenRouter says "Other," and neither gateway publishes a knowledge cutoff.

Two practical notes:

The data terms differ by route. If you're testing with company code, OpenCode's zero-retention wording is stricter than OpenRouter's retain-but-don't-train wording. The Chinese developer blog AI Pioneer gave the same advice.
Reasoning can't be switched off. Hiding the reasoning text doesn't stop the model from spending reasoning tokens. On OpenRouter the default effort is max, which affects both latency and token usage.

Timeline

Times are UTC unless noted.

Sep 23, 14:48: OpenRouter lists the model at $0. OpenCode lists Space Bunny Free the same day and calls it free for a limited time.
Sep 23, 15:25: X user cheatyyyy posts that the model's text tokenizer "perfectly matches" MiniMax M3's and that the image tokenizer looks different, possibly upgraded.
Sep 23, afternoon: YFarmX publishes a 50-string token-count comparison that places Space Bunny inside the MiniMax signature.
Sep 23, 22:23: A fan domain for the model is registered. More on that site below.
Sep 24: The developer behind the open-source stealthprint toolkit (GitHub user majiayu000) publishes a multi-layer fingerprint study on OpenCode Go. Chinese outlets, BlockBeats among them, report the community's MiniMax M3.1 theory.
Sep 26 (UTC+8): AI Pioneer reports that Space Bunny reached the top of OpenRouter's daily ranking, ahead of DeepSeek V4.1 Flash and GLM 5.3 Flash.
Sep 27 (UTC+8): IT Home reports that MiniMax announced M3.1-Flash-Preview inside MiniMax Code, with no model card or API price. MiniMax hasn't said it is Space Bunny.

Who's behind Space Bunny? The evidence, ranked

Identity claims vary a lot in quality. We sort them by how hard each one would be to fake or misread.

Evidence	What it shows	Source	Strength
Token counts match MiniMax on 50 of 50 strings; the next-closest family scores 29	MiniMax tokenizer family	YFarmX	Strong
24 of 24 probes match live MiniMax M3 and M2.5 endpoints on the same gateway; Kimi models differ on 14 of 24	MiniMax family; argues against Kimi	stealthprint	Strong
Accepts inputs of 1M tokens, while MiniMax M2.5's endpoint caps at 204,800	Newer than the M2.5 generation	stealthprint	Moderate
Knows events from November 2025 that M3 doesn't	Possibly fresher training than M3	stealthprint (labeled medium-confidence inference)	Moderate
M3.1 entries with 1M context and low, high, and max effort in MiniMax Code test files	MiniMax is preparing an M3.1	Reported by BlockBeats and EyesTech	Circumstantial
Corrupted-image error text reportedly identical to MiniMax's own "(2013)" error	MiniMax serving stack	Summarized by AI Pioneer; stealthprint found the gateway's errors normalized on its route	Disputed
Says "I'm ChatGPT" or "GPT-5, created by OpenAI"	Nothing reliable	YFarmX and stealthprint, both of whom attribute it to the missing identity prompt	Weak
Reconstructed prompt resembles OpenAI's Harmony format and uses a "Juice" budget field	Possible OpenAI link	Unofficial fan site	Speculative
Moon, rabbit, and Mid-Autumn Festival timing, which suggests Moonshot's Kimi	Name association only	Community chatter	Weak
"Space" in the name, so SpaceX or xAI	Meme	Community chatter reported by AI Pioneer	None

Our read: Space Bunny is very likely a MiniMax-family model, and probably newer than M3. That's a reasonable conclusion from independent tokenizer work. "It is exactly MiniMax M3.1" isn't confirmed. A tokenizer shared across generations can't pin down a checkpoint, and MiniMax's September 27 M3.1-Flash-Preview announcement didn't mention Space Bunny.

Past stealth listings eventually got claimed by their vendors. Siora Labs notes that the previous OpenRouter stealth model, Ox Alpha, was revealed as GLM-5.3-Flash and stopped being free at the reveal. It's reasonable to expect the same for Space Bunny, but that's an expectation, not a fact.

A note on the unofficial fan site

A site named after the model's slug appeared within hours of launch. Domain records show it was registered on September 23 at 22:23 UTC, about seven and a half hours after the OpenRouter listing. It calls itself an "independent field guide," doesn't name its operator, and promotes an unrelated local AI audio app.

It isn't run by OpenRouter, OpenCode, or any model lab. Its most-cited numbers come from its own benchmark subsets: 82.0% on 60 GPQA Diamond questions, 46.1% on 300 Humanity's Last Exam questions, and 7.0 out of 10 on the AI BENCHY suite. They're interesting data points, but they aren't vendor results, and you shouldn't compare them directly with full-benchmark scores.

Should you use it?

It's worth trying for open-source work, prototypes, and long agent sessions while it's free. That's where public reports are most positive. Don't use it for production traffic or sensitive code without checking the route's data terms. There's no model card or official benchmark, and the free window is explicitly temporary. OpenCode's offer was announced as roughly one week, and AI Pioneer read the public records as ending around September 30.

For test cases (Minecraft builds, SVG animations, image-to-app demos, video annotation, long-context retrieval, speed measurements) and a prompt set you can reuse, see our companion post on Hugging Face, "Space Bunny Tested: Real Cases and How to Evaluate a Stealth Model."

Using BeatAPI alongside a stealth preview

BeatAPI doesn't offer Space Bunny. We checked the public model catalog on September 27, 2026. What BeatAPI does offer is the set of named models you'd want to test a stealth model against, all behind one API key:

MiniMax-M3, the closest confirmed relative, at $0.21 input and $0.84 output per million tokens. MiniMax's official standard price is $0.30 and $1.20 for requests up to 512K input tokens.
claude-opus-5-5 at $2 input and $10 output per million tokens. Anthropic's official list price is $4 and $20.
deepseek-v4.1-flash and glm-5.3-flash, the two Flash models Space Bunny is most often compared with in public tests.

The same key covers social data from X, Reddit, YouTube, TikTok, WeChat Official Accounts, and more, which is how you'd monitor a launch like this without scraping. For agents, the MCP server exposes catalog search, price inspection, and runs in one place.

Start with the model catalog, connect an agent at the MCP entry, or give your coding agent skill.md.

FAQ

What is Space Bunny?
It's an anonymous stealth AI model offered free on OpenRouter (Space Bunny Alpha) and OpenCode (Space Bunny Free) since September 23, 2026. It has a 1M-token context window and accepts text, image, and video input.

Who made Space Bunny?
Nobody has said officially. Independent tokenizer studies by YFarmX and stealthprint place it in the MiniMax family.

Is Space Bunny MiniMax M3.1?
That's unconfirmed. MiniMax announced M3.1-Flash-Preview on September 27, 2026, without linking it to Space Bunny.

Why does Space Bunny say it's ChatGPT?
Testers who fingerprinted it say the stealth setup gives the model no identity, so it improvises one. Self-identification isn't reliable evidence.

Is Space Bunny free, and for how long?
OpenRouter lists it at $0, and OpenCode calls it free for a limited time. Neither gives a firm end date. Stealth previews usually stop being free when the model is officially revealed.

How to Make Videos with Claude Opus 5.5: A Deterministic Render Pipeline

Eric Kang — Mon, 28 Sep 2026 03:12:44 +0000

Originally published on BeatAPI.

TL;DR: Claude Opus 5.5 outputs code, not video frames. For code-rendered motion graphics, ask it to write a scene that can render any requested time t. Playwright can capture each frame of an HTML scene, and ffmpeg can encode those frames to MP4. Below is a prompt, a runnable render loop, a sample visual, and a cost calculation for one reported token budget. Model tokens are one cost; hosted rendering, narration, licensed assets, and optional video generation can add others.

Can Claude Opus 5.5 make videos?

Not directly. Anthropic released Opus 5.5 on September 22, 2026, as claude-opus-5-5, with a 1M-token context window and up to 128K output tokens. It outputs text only.

It can write animation programs, plan a storyboard, and revise code after render checks. The public examples show what is possible, but their quality, token use, and production time depend on the prompt and surrounding tools:

Deedy Das (@deedydas) demonstrated code-rendered video using JavaScript, a headless browser, and ffmpeg. The LaunchVideo team credits that demonstration as its inspiration.
LaunchVideo, a public, source-available demo, takes a product URL or prompt and renders a short launch film. Its creators report about four minutes and roughly 90,000 input plus 15,000 output tokens per film. Those are their figures, not our benchmark.

How Claude Opus 5.5 turns code into video

For an HTML or Canvas scene, the pipeline has four steps:

Opus 5.5 writes a scene. For this tutorial, that is one HTML file with Canvas or SVG.
A headless browser samples it. Playwright moves the scene to time t, takes a screenshot, and repeats for every frame.
ffmpeg encodes the frames into H.264 and muxes in audio.
Optional audio comes from a separate audio file, generated sound, or TTS, then gets muxed into the MP4.

The rule that makes this reliable is determinism. The renderer doesn't run in real time: frame 400 might be captured seconds after frame 399. In this simple renderer, nothing on screen should depend on the wall clock. Avoid Date.now(), requestAnimationFrame loops, CSS transitions, and timers unless you replace their clocks with a deterministic virtual clock. Seed random values. Then each frame can depend on t, the input data, and fixed assets, which makes individual scenes easier to re-render and compare.

Four ways to make videos with Opus 5.5

A. Single HTML file + Playwright + ffmpeg. A small starting point for launch clips, social videos, and animated charts. Use a beat sheet and a few keyframes before asking for the full scene.
B. Remotion, HyperFrames, or Manim. Alternatives for longer compositions and explainers; each has its own rendering workflow. Time narration to word timestamps if you need voiceover. Remotion's free license covers individuals and teams of up to three people; larger organizations need to check its current license terms.
C. Product-repo video. Let the model inspect real UI components and assets, then verify the rendered result against the product. Do not use a plausible imitation as a product demo.
D. Longer assisted runs. Split the storyboard into scenes, render each scene, review joins and audio, then assemble the final film. More iterations and optional generated footage increase cost.

Explore the source-linked examples: Awesome Opus 5.5 Videos collects 20 creative-coding video and scene leads with creator attribution and links to original posts. These entries are marked source-listed; BeatAPI has not independently reproduced the works or verified every model claim. You can also browse the gallery.

Claude Opus 5.5 video tutorial: HTML to MP4

Install the tools:

npm i playwright && npx playwright install chromium   # plus ffmpeg from your package manager

Ask Opus 5.5 for scene.html using the prompt template below. The scene must set window.DURATION and expose async window.seek(t). To check your local setup before making a model call, save this small, hand-written scene as scene.html:

<!doctype html>
<style>body { margin: 0; background: #0c1116; }</style>
<canvas id="frame" width="1080" height="1080"></canvas>
<script>
window.DURATION = 2;
const ctx = document.querySelector("#frame").getContext("2d");
window.seek = async (t) => {
  ctx.fillStyle = "#0c1116";
  ctx.fillRect(0, 0, 1080, 1080);
  ctx.fillStyle = "#5be2a1";
  ctx.beginPath();
  ctx.arc(120 + 400 * t, 540, 80, 0, 2 * Math.PI);
  ctx.fill();
};
</script>

Then save the following as render.mjs and run node render.mjs scene.html out.mp4. It should produce a two-second square clip with a moving green circle. Replace the test scene with Opus's HTML only after that local check, and inspect its frames before using it in a published video:

// render.mjs — node render.mjs scene.html out.mp4
import { chromium } from "playwright";
import { spawn } from "node:child_process";
import { once } from "node:events";
import path from "node:path";
import { pathToFileURL } from "node:url";

const [scene, out, fps = 30] = process.argv.slice(2);
if (!scene || !out) throw new Error("Usage: node render.mjs scene.html out.mp4 [fps]");
const browser = await chromium.launch();
const page = await browser.newPage({ viewport: { width: 1080, height: 1080 } });
await page.goto(pathToFileURL(path.resolve(scene)).href);
await page.waitForFunction(() => typeof window.seek === "function");
await page.evaluate(() => document.fonts.ready);
const total = Math.round((await page.evaluate(() => window.DURATION)) * fps);

const ff = spawn("ffmpeg", ["-y", "-f", "image2pipe", "-framerate", `${fps}`, "-i", "-",
  "-c:v", "libx264", "-pix_fmt", "yuv420p", "-crf", "18", out],
  { stdio: ["pipe", "inherit", "inherit"] });
for (let i = 0; i < total; i++) {
  await page.evaluate((t) => window.seek(t), i / fps);
  if (!ff.stdin.write(await page.screenshot({ type: "png" })))
    await once(ff.stdin, "drain");
}
ff.stdin.end();
const [exitCode] = await once(ff, "close");
await browser.close();
if (exitCode !== 0) throw new Error(`ffmpeg exited with ${exitCode}`);

We used a hand-written six-second, 1080×1080, 30-fps scene to check the renderer. The frame below shows a sample TikTok follower chart; it is not a Claude-generated clip or a real account's data. For longer films, render scenes separately and join them with ffmpeg's concat demuxer. Add audio in a second pass with -c:v copy.

Sample frame from the local renderer test. The numbers and scene are synthetic.

The same pattern works for data-driven videos. If the scene reads its numbers from a JSON file, one scene can render a creator's growth recap, a weekly top-posts reel, or one version per platform. The same BeatAPI key that calls Opus 5.5 also covers social media data tools (for example, TikTok, YouTube, Instagram, and X profiles and posts). An agent connected to the hosted MCP server can fetch those and write the JSON for you.

Prompt template

Make a {LENGTH}s video about {TOPIC} for {AUDIENCE}.
Output ONE self-contained HTML file, {W}x{H}, no network requests.
Contract: set window.DURATION = {LENGTH}; expose async window.seek(t).
Every pixel is a pure function of t. No Date.now, requestAnimationFrame
loops, timers, CSS transitions, or unseeded Math.random.
Style: palette {HEX COLORS}, font {FONT}, motion "{e.g. snappy, no fades}".
Facts (use only these): {VERIFIED BRIEF}
Audio: {voiceover word timestamps, or target BPM with cuts on beats}.
First reply with a beat sheet and 4 keyframes only; write the file after I approve.

The Facts and Style lines matter most. Check every factual statement against the supplied brief, then inspect frames at the beginning, middle, and end before rendering the whole scene.

Cost: what a video costs in Opus 5.5 tokens

An illustrative calculation. LaunchVideo reports about 90,000 input and 15,000 output tokens per film. At standard uncached list prices checked on September 27, 2026:

	Input (90K tokens)	Output (15K tokens)	Per video	Per 100 videos
Anthropic list ($4 / $20 per M)	$0.36	$0.30	$0.66	$66
BeatAPI list ($2 / $10 per M)	$0.18	$0.15	$0.33	$33

This estimates model tokens for one reported generation budget. It excludes rendering infrastructure, TTS, paid assets, retries, cached-token rules, and any generated footage. Thinking tokens contribute to output usage. A 50% difference follows only for the compared standard input and output rates at the same token counts; it is not a guarantee about the total video budget. Check the current rate and a representative settled request before scaling up.

For a separate model-version comparison and migration checklist, see the Opus 5.5 vs Opus 5 guide.

Using Opus 5.5 through BeatAPI

The Claude Opus 5.5 API page is the next step if you want to call the model through BeatAPI. It shows the current model ID, request formats, price, and the route to create a key. On September 27, 2026, its public catalog listed:

Model: claude-opus-5-5, with a 1M-token context and 128K max output tokens.
Price: $2 per million input tokens and $10 per million output tokens (listed as 50% off on the homepage).
Endpoints: OpenAI Responses (/v1/responses), OpenAI Chat Completions (/v1/chat/completions), and Anthropic Messages (/v1/messages). They return JSON directly or stream.
Optional data source: the same account can access the currently listed Social Data actions through https://beatapi.io/mcp. A profile response is a snapshot; a growth chart needs separately collected historical snapshots.

Switching an existing OpenAI SDK integration is a base-URL change (illustrative, not run):

import os
from pathlib import Path
from openai import OpenAI

client = OpenAI(
    base_url="https://api.beatapi.io/v1",
    api_key=os.environ["BEATAPI_API_KEY"],
)
prompt = (
    "Write a self-contained six-second 1080x1080 HTML animation. "
    "Set window.DURATION=6 and expose async window.seek(t). "
    "Use only deterministic drawing; return HTML only, with no code fences."
)
response = client.chat.completions.create(
    model="claude-opus-5-5",
    messages=[{"role": "user", "content": prompt}],
    max_tokens=12000,
)
html = response.choices[0].message.content or ""
if not html.lstrip().lower().startswith("<!doctype html>"):
    raise ValueError("Review the model response before saving it as HTML")
Path("scene.html").write_text(html, encoding="utf-8")

Tools that speak Anthropic Messages can point their Anthropic base URL at https://api.beatapi.io, and the client appends /v1/messages. BeatAPI's integration docs describe this for Claude Code through ANTHROPIC_BASE_URL. Set the model to claude-opus-5-5 and keep your key in an environment variable, not in chat or source files.

Limitations

Code-only scenes are motion graphics. They do not create filmed footage or natural lip-sync by themselves. Add licensed footage or another generation step if you need it.
Visual quality varies. A scene may look like animated slides; inspect the result and revise the storyboard, typography, and timing.
Factual errors are possible. Supply a verified brief for explainers and review the rendered claims.
Long runs can break. Subagent chapters may not join cleanly, and the model sometimes slips a timer into the scene. Render short test ranges first.
Long jobs need process supervision. Keep the renderer running until ffmpeg exits successfully and check the final MP4 before treating the job as complete.
Setup is still required. You need Node, Playwright, Chromium, ffmpeg, and optionally TTS.

FAQ

Can Claude Opus 5.5 generate video directly?

No. It outputs text only. It makes videos by writing animation code that a headless browser renders frame by frame and ffmpeg encodes into an MP4.

What do I need to make a video with Opus 5.5?

Node.js, Playwright with Chromium, and ffmpeg, plus access to the model. A TTS engine such as Kokoro-82M or ElevenLabs is optional for narration. Remotion, HyperFrames, and Manim are optional frameworks.

How much does an Opus 5.5 video cost?

For the 90K input and 15K output tokens reported by LaunchVideo, standard uncached token pricing gives an illustrative $0.66 at Anthropic's list price or $0.33 at BeatAPI's listed price on September 27, 2026. Rendering, revisions, audio, and other assets are additional.

Why does the scene need a seek(t) function?

The renderer captures frames at its own pace, not in real time. If every frame depends only on t, the video comes out identical on every render and can be rendered in parallel.

Can I call Opus 5.5 through BeatAPI with my existing code?

Yes, if your code uses OpenAI Chat Completions, OpenAI Responses, or Anthropic Messages. Change the base URL to BeatAPI, use your BeatAPI key, and set the model to claude-opus-5-5.

If you want to use BeatAPI for the model call: check the current claude-opus-5-5 rate and request format on the Opus 5.5 API page, then render and review one short scene before attempting a longer video.

Meta Muse in 13 Real-World Tests: What to Delegate, What to Verify

Eric Kang — Sat, 26 Sep 2026 10:33:14 +0000

What to hand Meta's AI agent first, what to double-check, and which settings to change on day one. Built from real tests by CNN, WIRED, The Verge, Yahoo Finance, Inc., Ars Technica and independent reviewers.

Most Muse guides show you the launch demo. This one is built from what happened when real people handed Muse real errands in its first three weeks.

The range is wide. When Yahoo Finance's Daniel Howley asked Muse for moving quotes, it contacted four local movers, and two called back within about two minutes. Around the same time, Inc. columnist Jason Aten says he declined to give Muse access to his Messages. According to Aten, the Mac app later synced more than 187,000 rows of his message history anyway.

Both of those outcomes are possible with the same product. The goal of this guide is to get you the first one and keep you clear of the second.

What you'll learn:

What Muse is, where to get it and what it costs
How to set it up safely in five steps
What to delegate first, based on tests that worked
What to double-check, based on tests that didn't
The trust issues you should know about
A day-one safety checklist and a task template you can copy

Part 1: What Muse is

Muse is Meta's personal AI agent, launched in the US on September 8, 2026. A chatbot answers your question and leaves the work to you. Muse takes a goal and carries it out: it sends the email, fills in the form, books the table and follows up.

Here's what makes it work:

Its own computer. Each user's agent runs on a dedicated cloud virtual machine with its own browser, which Meta calls Muse Secure VM.
It keeps working in the background. Longer tasks continue after you close the app. Muse checks back when something changes or when it needs your approval.
Memory. It remembers what you tell it and uses it later. You can edit that memory or ask it to forget things.
Connectors. You link services like Gmail, Google Calendar and Outlook, and you choose how much access each one gets.

The basics:

Where: In the US on iOS, Android, the web at muse.ai, and WhatsApp. There's also a Mac app, and at Connect on September 23 Meta added computer use, which lets Muse operate apps on your Mac with your permission. Support for Meta's AI glasses is coming later.
Cost: There's a free tier with a usage meter. Mark Zuckerberg put the free limit at up to 100 million "Muse tokens" a week. Paid plans are Power ($20/mo) and Maximum ($100/mo). TechCrunch reported at launch that a payment card is required to get started.
Not the same as Meta AI: The Meta AI assistant inside Instagram and Messenger is a separate product.

Part 2: Set it up safely in five steps

Step 1: Sign up and name your agent.

Sign up at muse.ai or in the app. The default avatar is Jolly, but you can rename it and change how it looks. Reviewers have given theirs names like Pip and Lyra.

Step 2: Connect your calendar first, then your email as read-only.

When you connect email, Meta lets you choose whether Muse can only read your mail or can also send on your behalf. Start with read-only. Upgrade after you've watched it work for a week.

Step 3: Turn off AI training if you don't want to contribute.

It's on by default. According to WIRED, go to Settings → Data controls in the Muse app and switch off Help improve our AI models.

Step 4: On a Mac, check two permissions.

Meta says Muse can read Messages only if macOS Full Disk Access is granted and the Messages connector is on. Open System Settings → Privacy & Security → Full Disk Access. If you didn't mean to give Muse access to your whole disk, turn it off. Then check the Messages connector inside Muse. Aten says he found it enabled after declining it.

Step 5: Keep purchases on one-at-a-time approval.

Muse should ask before any purchase. Read exactly what it's buying, including the tip. Checkout runs through Link by Stripe, which Meta says generates a one-time card number so your real card stays hidden.

Part 3: What to delegate first

These are the tests that went well. They have one thing in common: the work is mostly coordination, not judgment.

Get quotes from movers — Daniel Howley, Yahoo Finance: ✅ Contacted four movers. Two called back within about two minutes; others replied by email.
Book a date night — Howley; Lisa Eadicicco, CNN: ✅ Howley booked one of four suggestions through OpenTable. CNN's Friday date night got booked too.
Set a fantasy football lineup — Howley: ✅ Put in a waiver claim for the Chiefs defense, dropped Green Bay, and started KC once the claim cleared.
Plan a trip with a friend — Eadicicco, CNN: ✅ Emailed a friend about Cape May, then turned the friend's restaurant picks into a Google Doc with alternatives.
Build a moving-week packing plan — Eadicicco, CNN: ✅ Made a day-by-day schedule with time budgets, plus tips like packing a "first night" bag.
Clean out a Gmail inbox — Emma Roth, The Verge: ✅ Deleted thousands of promotional emails on a laptop. ⚠️ Google sign-in kept glitching on mobile.
Buy workout tops — Roth, The Verge: ✅ Noticed other items already in the cart, asked about them, and bought only the tops.

1. Errands that are mostly back-and-forth

The moving quotes are the ideal Muse job. None of it is hard, it's just tedious: find the companies, answer the same questions four times, wait for callbacks. Muse turned all of that into one short conversation.

CNN's trip planning worked for the same reason. Muse emailed a friend, waited for the reply, then turned the recommendations into a shared doc. A chatbot can't do that, because a chatbot doesn't wait around for someone to write back.

Rule of thumb: if a task is mostly emailing, form-filling and following up, hand it over.

2. Actions inside accounts you already use

Connected to Yahoo Fantasy, Muse compared projected points, put in a waiver claim for Kansas City, dropped Green Bay and set Howley's lineup once the claim processed. Those were real actions in a real account. For The Verge's Roth, it cleared thousands of promotional emails out of Gmail. On a shopping run, it noticed other items sitting in the cart and asked whether to remove them before checkout.

3. Planning with constraints

Eadicicco told Muse what was left to pack, how much time was available, and a preference for packing in short spurts. Muse came back with a day-by-day plan. Constrained planning plays to what language models do well, and Muse adds the follow-through.

Good first tasks to copy:

"Get quotes from three movers for a two-bedroom, second floor, no elevator. Don't book anything."
"Find an evening next week when we're both free and suggest three restaurants nearby. Show me before booking."
"Every morning, summarize today's calendar, deliveries and bills that are due."

Part 4: What to double-check

These are the tests that went wrong. Almost every failure comes from Muse acting on information that was wrong or out of date.

Find restaurants for date night — Eadicicco, CNN: ❌ Two suggestions had been closed for years.
Find gluten-free beer nearby — Howley: ⚠️ Two good picks and one spot that had been closed for years. It also gave a phone number, then admitted it had made that number up.
Buy a winter jacket — MBI Deep Dives: ❌ After recommending a Patagonia jacket, Muse said the discount it had shown was no longer available.
Haggle on Facebook Marketplace — Eadicicco, CNN: ❌ Said it couldn't message sellers directly, only draft a message to send manually.
Order breakfast from a bakery — Reece Rogers, WIRED: ⚠️ Built the order but selected "no tip." Rogers ended up ordering in person.
Connect iCloud email — Taylor Arndt, Substack: ⚠️ Built a custom iCloud tool on request, but it didn't persist and kept needing an app password.

It can rely on stale data

CNN and Yahoo Finance were both sent to restaurants that had been closed for years. When Howley pointed it out, Muse apologized and said it had initially relied on stale data. MBI Deep Dives was shown a Patagonia discount that no longer existed.

What to do: treat every address, price, discount and "open now" as a draft. Ask Muse for the source link and click it.

It can invent details

Howley asked for a restaurant's phone number. Muse gave one, then said to use a different one, and when asked why, admitted the first number was made up. To its credit, it then warned Howley not to trust unverified numbers.

What to do: verify phone numbers and opening hours before you call or show up.

The marketing can run ahead of the product

Muse's own Ideas tab told CNN it could message Marketplace sellers and negotiate the price. When Eadicicco tried, Muse said it could only vet listings and draft a message. Meta told CNN that Muse can negotiate within user-set parameters, and in WIRED's test Muse did offer to message couch sellers. Results vary.

What to do: try a new capability once on something low-stakes before relying on it.

Some choices need a human

On WIRED's bakery order, Muse picked "no tip." It's a small thing, but it's exactly the kind of social judgment you don't want an agent making quietly.

What to do: read the full order before approving it, not just the total.

Accessibility still has gaps

Taylor Arndt, who is blind and uses Apple's VoiceOver, ran into a name field that didn't behave like a normal text field, chat messages without headings, decorative images read aloud, and an unlabeled control in the Mac app's setup. Arndt still wants to use Muse, and wrote the review hoping it gets fixed.

Part 5: The trust issues you should know about

You don't need to avoid Muse, but you should know what happened in its first three weeks:

The iMessage incident. Aten says he declined Messages access during setup, yet Muse later showed it as enabled and synced his message history from his Mac. When asked, Muse wrongly claimed it had only seen notification previews. David Singleton, who leads Meta Superintelligence Labs, wrote on Threads that the Messages integration is opt-in and requires both Full Disk Access and the Messages connector. Decrypt reports Singleton called the made-up explanation "on us." Aten says Meta hasn't explained how the access got switched on.
A zero-day, then a hotfix. macOS security researcher Patrick Wardle found that a local app or terminal command could redirect where Muse sends voice transcription and use that to steal the token controlling a user's Muse account. Ars Technica reports that Meta shipped a hotfix more than 12 hours after its story went live. Meta called it "not a remote exploit."
Amazon blocked it. On September 20, Amazon began blocking Muse from shopping on Amazon.com, calling it an unauthorized AI agent. Amazon says Meta never told it that Muse would access the store, that the agent doesn't identify itself, and that it appears to capture customer credentials. Meta has said Muse can't see users' passwords or payment methods.
Humans behind some calls, in testing. Reuters, citing internal posts, reported that Meta tested having human contractors quietly handle some phone calls placed through Muse. A vice president in Meta Superintelligence Labs wrote internally that starting without proper disclosures "was a miss" and that the feature had been rolled back for now.
Training is on by default. WIRED reports that interactions are used for AI training unless you opt out. Meta says the data is "sanitized" first. Muse's Memory document can be edited or wiped, but memory itself can't be switched off.
It infers more than you'd expect. Asked what it knew from Roth's connected Instagram and Facebook accounts, Muse listed interests like anime, CrossFit and Labrador retrievers, which was more detail than Instagram's own ad-topics page showed. A news feed it built drew on the shipping address from an Amazon order. Meta told The Verge you can disconnect Instagram from Muse in Accounts Center.

To be fair, Meta has published an unusually detailed security design: a per-user VM, a separate "Sentinel" agent that must approve anything Muse sends to the internet, credentials Muse can use but not see, and one-time payment cards. It has also promised a "Confidential VM," encrypted with a key only you hold, later this year. The architecture is serious. The first three weeks show the edges still need work.

Part 6: Your day-one checklist

[ ] Connect only your calendar and email, with email on read-only
[ ] Turn off Help improve our AI models under Settings → Data controls
[ ] On a Mac, check Full Disk Access and the Messages connector
[ ] Approve purchases one at a time, and read the whole order
[ ] Ask for source links on any fact you'll act on
[ ] Skim the audit trail every few days
[ ] Open the Memory document (tap the avatar at the top) and prune it
[ ] Disconnect anything you're not actively using

A task template you can copy

Goal: [what you want done]
Limits: Only use [sources/accounts]. Don't [send / book / pay / cancel] anything without asking me.
Output: Give me [a table / three options / a draft], with source links for any prices, addresses or phone numbers.

Example:

"Get quotes from three movers for a two-bedroom, second floor, no elevator, moving on October 15. Don't book or pay for anything. Give me a table with price, availability and contact info, with a link for each company."

FAQ

Is Muse free?
Yes, up to a weekly usage limit. The Power ($20/mo) and Maximum ($100/mo) plans add more usage.

Can it spend my money without asking?
It's designed to ask before any purchase. Keep per-purchase approval on, and read the full order.

Can it shop on Amazon?
Not reliably right now. Amazon began blocking Muse on September 20.

Will my data be used for ads?
Meta says conversations and VM data aren't shared with its ads systems. Model training is a separate setting, and it's on by default.

What should I try first?
Something tedious and easy to check: moving quotes, a packing plan, trip logistics, or a daily summary.

The bottom line

Across every test, the pattern holds. Muse is good at doing things and unreliable at knowing things. It's excellent at the connective tissue of life admin: the emailing, form-filling, following up and scheduling that eat your week. It's shaky on facts, and at least one user's experience suggests it can reach further into your data than you meant to allow.

Treat it like a sharp new assistant on day one. Give it real work, check what it tells you, and don't hand over every key yet.

For builders: giving an agent fresher information

Most failures in Part 4 trace back to the same gap. Muse could act, but the information it acted on was out of date.

That's the layer we work on at BeatAPI. Connected to Muse as an MCP connector (BeatAPI MCP), it lets Muse run live web searches, read pages, search current public social data and call text, image and video models through one API key. The key stays in Muse's secure connector field, never in chat, and the setup prompt tells Muse to show you the live price and get your OK before any paid run. It won't make an agent infallible, but it gives it a way to check before it acts.

Setup takes one prompt: beatapi.io/muse →

Sources

Details reflect reporting through September 26, 2026. Features, pricing and policies are changing fast.