From Claude Fable 5.2 Cracking a Black Hole Physics Problem: How to Choose APIs for Heavy Agent Tasks to Be More Stable and Cost-Effective

Author’s note: This article draws on the official research post about Claude Fable 5.2 completing two black hole physics problems with multiple agents, and distills actionable practices for heavy Agent tasks—model selection, role splitting, and setting stop lines.

On November 17, 2026, Anthropic published a research post: multiple copies of Claude Fable 5.2 ran in the background for roughly six weeks and worked through two black hole physics problems. For developers running long tasks and multi-agent systems, the interesting part isn’t the physics itself—it’s the way of working: long-running, multi-path, mutually cross-checking.

This isn’t a physics explainer, and it won’t tell you which API provider is more reliable. It does one thing: translate the engineering signals worth borrowing from the research post into steps you can follow when running your own heavy Agent tasks.

Core value: By the end, you’ll know how to split primary reasoning and review into different roles, write clear stop lines for each agent path, and choose only among models with clear pricing in the model table—so long-task costs are predictable and capped.

claude-fable-5-2-heavy-agent-task-api-selection-en-image-0


What the Claude Fable 5.2 Research Post Reveals About Heavy Agent Tasks

Let’s start with the backstory in a paragraph or two. The research post is Anthropic’s own account, and the two papers it involves are currently preprints — not yet peer-reviewed. Both problems come from theoretical physics, describe a universe that isn’t ours, and have no practical application, so the significance lies in the method, not in how important the conclusions are.

According to the post, in August 2026 researcher Hongbin Chen asked Claude to list open problems in black holes and bootstrap; a few hours later he had 22 of them. He assigned a separate agent to each problem, let the agents read each other’s progress, and ran them in the background for roughly six weeks. The post’s exact wording is “no special configuration,” but that’s the official description of how it was set up — it doesn’t mean zero cost, and the post doesn’t provide a cost breakdown.

Facts from the research post Implications for heavy agent tasks What you can do
One agent per problem; agents can read each other’s progress Task decomposition needs clear granularity, and shared state needs to be readable A separate agent per subtask, with progress written to shared storage
Nearly every step performed independently by two agents, then checked against the literature Critical steps need independent review Split main reasoning and review into two roles
Early agents tried 61 times in parallel and got nowhere Failure is the norm, but failures need a ceiling Spell out the maximum number of failures and the budget for each path
Results verified through Lean formalization and checked by physicists Machine results ultimately need external validation Leave a step for human or tool-based verification
Ran in the background for about six weeks Costs accumulate on long-running tasks Estimate from per-model list pricing and set a spending cap

What Each of the Two Problems in the Heavy Agent Task Shows

The first problem is the Hawking-Page phase transition calculation, first posed back in 2003 and never finished. The post says nearly every step was performed independently by two copies of the agent, then checked against the literature, and the conclusion is that the transition remains abrupt at weak coupling. Another physicist independently arrived at the same answer using a different method, giving cross-validation. For engineering practice, what this problem demonstrates is the “independent repetition + external cross-check” verification approach.

The second problem is the upper-bound question for the simplest version of modular bootstrap. An earlier batch of Claude agents made 61 attempts in parallel without success; later agents spotted a pattern in the numerical results, borrowed a method from another sphere-packing problem, and proved that the upper bound on the lightest black hole mass is roughly c/9.1266 — and also showed that this method can’t push the bound any lower. In September 2026, the result was formally verified with Lean, the paper was written by Claude, and physicists checked the main results. The engineering lesson here: a large number of failed attempts is simply part of the process, so every path needs a budget and stopping conditions.

One thing worth calling out: the approach in the post is “multiple copies of the same model checking each other,” not “plan with an expensive model and verify with a cheap one.” The role-splitting cost-saving scheme described below is an engineering practice readers can try — not a conclusion this research has already validated.

claude-fable-5-2-heavy-agent-task-api-selection-en-image-1


How to Split Roles in Heavy Agent Tasks: Separating Main Reasoning from Review

In heavy agent tasks, the most expensive part is usually the path that needs deep reasoning, while the most frequent is review work like checking, comparing, and format validation. If every call goes through the same most expensive model, costs grow linearly—or even superlinearly—with the number of turns. Splitting “thinking it up” and “checking it over” into two roles is the most direct way to control costs.

The principle behind the split can be summed up this way: steps that require open-ended reasoning and long-chain planning go to the main reasoning role; checks with clear-cut criteria—things like “is this step consistent with the previous one,” “is the output format compliant,” “does the conclusion conflict with known literature”—go to the review role. What the review role returns should be a structured judgment, not a fresh re-derivation.

Role Responsibilities Candidate model IDs Output requirements
Main reasoning Open-ended derivation, solution generation, key steps claude-fable-5-2, claude-fable-5-2-thinking Full reasoning process and intermediate conclusions
Level-1 review Logical consistency, step comparison, citation checking claude-sonnet-5-5 PASS / FAIL plus reasoning
Lightweight validation Format checks, field completeness, simple comparisons claude-haiku-5-5 Structured JSON results
External validation Formal proofs, numerical verification, human review Tools or humans Final confirmation

Once you split things this way, all roles can go through a single entry point. With APIYI apiyi.com, one API key lets you switch between the models in the table above. The interface is OpenAI-compatible, so main reasoning and review only need a change to the model parameter—no need to maintain multiple SDKs or multiple keys. For long tasks that need parallel paths, the unified entry point also keeps usage statistics in one place, which makes reconciling them easier.

One caveat, though: a cheaper review model doesn’t mean a more reliable one. Whether the review role can do the job depends on whether the criteria you give it are clear enough. I’d suggest running a small batch of samples with known answers first to confirm the review model’s pass/reject judgments roughly match expectations, then putting it into long tasks.

Choosing an API for Heavyweight Agent Tasks: Match Price to Model ID

Budget control for long-running tasks starts with one premise: the unit price of every call is fixed. A good rule of thumb is to stick to models that have a clearly listed price in the model table, and to hard-code the model ID and its corresponding unit price in your code rather than swapping them on the fly during a run.

According to Anthropic’s official model page, Claude Fable 5.2 was released on November 9, 2026. Its model ID is claude-fable-5-2, it has a 1M-token context window and a maximum output of 128K tokens, and thinking is enabled by default. The table below shows the listed prices for the models relevant to this article, in USD per million tokens, from the APIYI apiyi.com master model table as of the verification date (2026-11-19).

Model ID Input Cache read Output Suggested role in this article
claude-fable-5-2 8 0.2 40 Primary reasoning
claude-fable-5-2-thinking 8 0.2 40 Primary reasoning (thinking version)
claude-fable-5-1 10 0.25 50 Adjacent version, for comparison
claude-sonnet-5-5 2 0.1 10 First-level review
claude-haiku-5-5 0.1 0.01 0.5 Lightweight validation

There are a few takeaways from this table that matter a lot for long-running tasks. First, claude-fable-5-2 is listed at a lower price than the adjacent claude-fable-5-1; if your primary reasoning is still on the older version, it’s worth evaluating a migration. Second, the cache read price is only 2.5% of the input price. In long tasks, the agent repeatedly reads shared progress, system prompts, and background documents. If those reads hit the cache, the cost difference can be very noticeable. Whether they hit depends on the invocation method and platform rules, so refer to the documentation. Third, the per-token gap between the review model and primary reasoning spans orders of magnitude.

claude-fable-5-2-heavy-agent-task-api-selection-en-image-2

Let’s run through some hypothetical numbers to get a feel for it: one primary reasoning call with 50K input tokens and 8K output tokens costs about 0.4 + 0.32 = $0.72 on claude-fable-5-2; one review call with 20K input and 2K output tokens costs about 0.04 + 0.02 = $0.06 on claude-sonnet-5-5, and about $0.003 on claude-haiku-5-5. If you also use the primary reasoning model for review, the same review call costs about 0.16 + 0.08 = $0.24. This is just arithmetic for illustration; actual token counts depend on your task.

Also, on the official model page, Opus 5.5 is listed at $4 input and $20 output, Sonnet 5.5 at $2 and $10, and Haiku 5.5 starting at $0.10 and $0.50. These can serve as a reference for understanding the official pricing tiers. For actual calls, the model and price are subject to the platform’s model list. APIYI’s claude-fable-5-2 series supports both the chat and messages endpoints, with a unified base URL of https://api.apiyi.com/v1.


Getting Started Fast with Heavy Agent Tasks: Scheduling Code with a Kill Switch

Minimal Example

First, make sure the main reasoning model responds normally and that you can read the usage field — that’s the foundation for tracking costs later:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1",  # APIYI OpenAI-compatible endpoint
)

resp = client.chat.completions.create(
    model="claude-fable-5-2",
    messages=[{"role": "user", "content": "列出这一步推导需要独立核对的三个关键假设"}],
    max_tokens=2000,
)
print(resp.choices[0].message.content)
print(resp.usage)  # for token accounting and cost estimation

Set clear stop lines for every agent branch

The research post notes that the early agents made 61 attempts in parallel without a single success — a reminder that heavy Agent tasks will inevitably rack up a lot of failed attempts, and those failures cost money too. Stop lines exist so that each agent branch halts itself automatically before it runs out of control and hands the decision off to a human or a tool.

Stop line Meaning Suggested initial value (adjust per task)
Max rounds Upper limit on main-reasoning and review round-trips 10–30 rounds
Cost cap Upper limit on the cumulative estimated cost of a single branch Set according to your per-question budget
Consecutive no-progress Review kicks the work back repeatedly with no new conclusion 3–5 times
Max failures Cumulative number of times review has kicked the work back Roughly half the round count
Output length Token cap for a single output Well below the 128,000-token max output

View the full implementation code
from dataclasses import dataclass, field
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1",  # APIYI unified endpoint, shared by the main reasoning and review calls
)

# Unit price: USD / million tokens, hard-coded from the platform's price table; update manually when it changes
PRICES = {
    "claude-fable-5-2": (8.0, 40.0),
    "claude-sonnet-5-5": (2.0, 10.0),
    "claude-haiku-5-5": (0.1, 0.5),
}

SOLVER = "claude-fable-5-2"
REVIEWER = "claude-sonnet-5-5"


@dataclass
class StopLine:
    max_rounds: int = 20
    max_cost_usd: float = 5.0
    max_no_progress: int = 4
    max_failures: int = 10
    max_output_tokens: int = 8000


@dataclass
class RunState:
    rounds: int = 0
    cost_usd: float = 0.0
    failures: int = 0
    no_progress: int = 0
    notes: list = field(default_factory=list)


def estimate_cost(model: str, usage) -> float:
    """Estimates from list price; cache discounts aren't included, so the result is on the conservative side."""
    price_in, price_out = PRICES[model]
    return (usage.prompt_tokens * price_in + usage.completion_tokens * price_out) / 1_000_000


def call(model: str, messages: list, max_tokens: int, state: RunState) -> str:
    resp = client.chat.completions.create(
        model=model, messages=messages, max_tokens=max_tokens
    )
    state.cost_usd += estimate_cost(model, resp.usage)
    return resp.choices[0].message.content


def should_stop(state: RunState, line: StopLine) -> str | None:
    if state.rounds >= line.max_rounds:
        return "达到最大轮数"
    if state.cost_usd >= line.max_cost_usd:
        return "达到费用封顶"
    if state.no_progress >= line.max_no_progress:
        return "连续无进展"
    if state.failures >= line.max_failures:
        return "失败次数过多"
    return None


def run_task(task: str, line: StopLine = StopLine()) -> dict:
    state = RunState()
    progress = "(尚无进展)"

    while True:
        reason = should_stop(state, line)
        if reason:
            return {"status": "stopped", "reason": reason, "progress": progress,
                    "cost_usd": round(state.cost_usd, 4), "rounds": state.rounds}

        state.rounds += 1
        draft = call(SOLVER, [
            {"role": "system", "content": "你是主推理代理,只推进一步,写清依据。"},
            {"role": "user", "content": f"任务:{task}\n当前进展:{progress}\n请推进下一步。"},
        ], line.max_output_tokens, state)

        verdict = call(REVIEWER, [
            {"role": "system", "content": "你是复核代理,不重新推导,只判断。"
                                          "第一行只输出 PASS 或 FAIL,第二行给理由。"},
            {"role": "user", "content": f"已有进展:{progress}\n新的一步:{draft}"},
        ], 500, state)

        if verdict.strip().upper().startswith("PASS"):
            progress = draft
            state.no_progress = 0
            if "已完成" in draft:
                return {"status": "done", "progress": progress,
                        "cost_usd": round(state.cost_usd, 4), "rounds": state.rounds}
        else:
            state.failures += 1
            state.no_progress += 1
            state.notes.append(verdict)


if __name__ == "__main__":
    print(run_task("核对给定推导中每一步的符号约定是否一致,完成后写“已完成”"))

There are three deliberate design choices in this code. First, the price table is hard-coded, so anyone swapping models has to update the prices at the same time — that way you never end up with a “budget that’s quietly off because someone switched to an unpriced model”. Second, the reviewer role is told to output only PASS or FAIL plus a reason and is explicitly barred from re-deriving anything, which keeps the review output short. Third, once the loop stops it returns the current progress and the accumulated cost, so a human can take over the work instead of letting the agent retry forever.

🚀 Quick Start: Start with the free trial credits for new users on APIYI apiyi.com. Pick a small problem whose answer you already know, run it through the workflow above, and confirm that the review judgment and cost estimates match your expectations. Once they do, gradually increase the number of parallel paths and rounds.

FAQ: Choosing APIs for Heavy-Duty Agent Tasks

Q1: Is it credible that Claude Fable 5.2 solved hard black hole physics problems?

This comes from Anthropic’s own account in a research post dated November 17, 2026. The two related papers are preprints and haven’t been peer-reviewed yet. The result for the second problem was formally verified with Lean in September 2026, and another physicist independently arrived at the same answer to the first problem using a different method. Read it as an “official account + preprint” level of evidence.

Q2: The research post says “no special configuration.” Does that mean it was cheap?

No. “No special configuration” describes how it was set up, and the post doesn’t provide a cost breakdown. There were 22 problems, one agent per problem, running in the background for about six weeks. The call volume alone is substantial. If you run a task at a similar scale yourself, estimate costs from the model table’s listed prices and set a spending cap.

Q3: Is using a cheaper model for review a method verified in the research post?

No. The post’s approach was to have multiple copies of the same model independently redo the work and cross-check each other. “Use an expensive model for main reasoning and a cheaper model for review” is an engineering approach this article suggests you try; you’ll need to validate its effectiveness on your own tasks. For steps that demand extremely high correctness, you can also keep the “two main-reasoning runs independently redone” approach.

Q4: How do I choose between `claude-fable-5-2` and `claude-fable-5-2-thinking`?

Both are listed at the same price in the APIYI model table: input 8, cache read 0.2, and output 40 USD per million tokens. The official model page says thinking is on by default for Fable 5.2. For the exact differences between the two IDs in invocation behavior, refer to the platform’s model documentation. It’s best to run the same task a few times with each, compare output length and `usage`, and then decide which one to use for main reasoning.

Q5: How can I call both the main reasoning and review models through a single interface?

After signing up at APIYI apiyi.com and getting an API key, set the SDK’s base_url to `https://api.apiyi.com/v1`. To switch between main reasoning and review, you only need to change the `model` parameter, for example between `claude-fable-5-2` and `claude-sonnet-5-5`. New users get free testing credits, which is handy for validating your stopping limits and review logic first.

Q6: What’s the significance of cache read pricing in long tasks?

Fable 5.2’s cache read price is 2.5% of the input price, or $0.2 per million tokens. Multi-agent long tasks repeatedly read system prompts, background material, and shared progress. Keeping this content stable and placing it at the front of the prompt gives you a better chance of hitting the cache. Whether a cache hit occurs and how billing works are subject to the platform’s documentation.

Q7: What’s a suitable setting for the stopping limits?

There’s no universal number. Start with conservative values: 10-30 rounds, 3-5 consecutive runs with no progress, and a per-run cost cap based on the value of the problem. After you finish a batch, look at the distribution of stop reasons. If most stops are due to the “cost cap” even though the task was close to completion, loosen the limits appropriately. If most are due to “no progress for consecutive runs,” it means the task wasn’t broken down finely enough.

Q8: What limitations does this approach have?

First, the reviewer model can miss things or misjudge them, so you need to calibrate it with samples that have known answers. Second, the cost estimate is based on list prices — it doesn’t account for cache discounts or the swings from failed retries. Third, as with the research post, the final conclusion still needs outside verification, such as a formal proof or review by a domain expert. Agents approving each other doesn’t mean the result is correct.


Key Takeaways: Choosing an API for Heavy-Duty Agent Tasks

  • Frame the source: Fable 5.2’s black hole research is a self-report from the company, and the paper is a preprint — judge the method, not the conclusion
  • Split the roles: open-ended reasoning goes to the main reasoning model; checks with clear-cut criteria go to the reviewer model
  • Keep the review independent: the reviewer only judges, it doesn’t re-derive — output PASS / FAIL plus a reason
  • Always write down your stop lines: rounds, cost, consecutive lack of progress, and failure count — you need all four
  • Only use models with published pricing: hard-code the model ID and unit price in your code, and update the price whenever you switch models
  • Make good use of cache reads: put stable background and progress near the front; a cache read costs only 2.5% of the input price
  • Start from a single entry point: switch between the main reasoning and reviewer models with one APIYI key, and run small problems first on the free credits

Summary

Starting from the Claude Fable 5.2 black hole physics breakthrough, there are three things most worth borrowing for heavy agent tasks:

  1. Separate main reasoning from review: The research post had multiple copies of the same model cross-check each other. You can build on that by picking models at different price tiers for different roles, then validating review quality against samples.
  2. Write a clear stopping line for every path: 61 failed attempts show that failure is the norm — rounds, cost, no-progress, and failure counts all need hard caps.
  3. Only call models that have a price in the model table: put model IDs and unit prices like claude-fable-5-2, claude-sonnet-5-5, and claude-haiku-5-5 into the code, and costs become predictable and cap-able.

Whether a long task succeeds often doesn’t hinge on how smart any single call is — it hinges on whether the whole pipeline can keep moving forward within a controllable budget and leave behind verifiable results. We recommend starting with APIYI apiyi.com’s free trial quota to get one small task running end to end, then tuning parameters step by step based on the stopping reasons and scaling up from there.


📚 References

  1. Anthropic research post: the official write-up on Claude Fable 5.2 completing two black hole physics problems with multiple agents

    • Link: anthropic.com/research/claude-black-hole-physics
    • Description: a first-hand account of agent division of labor, duration, and review methods
  2. Preprint paper one: a preprint referenced by the research post, not peer-reviewed

    • Link: hexagonmath.org/2611.00175v1
    • Description: for readers who want to see the original results
  3. Preprint paper two: another preprint referenced by the research post, not peer-reviewed

    • Link: hexagonmath.org/2611.00174v1
    • Description: best read alongside the previous one
  4. Claude Fable 5.2 official model page: model ID, context window, max output, and official pricing

    • Link: platform.claude.com/docs/en/models/fable-5-2/overview
    • Description: use it to check model specs and the official pricing tiers

Author: APIYI Technical Team
Technical discussion: feel free to reach us via the APIYI website homepage; model and pricing details are available in the docs.apiyi.com documentation center

Leave a Comment