How to Use Claude Fable 5 Effort Levels: Low, Medium, High, and Max

Introduction: What You Will Build and Accomplish

Claude Fable 5 effort levels let you control how much reasoning depth, latency, and token budget the model uses for a task. Use this setting as your main performance knob: choose low when speed and cost matter most, medium for balanced production workloads, high for quality-sensitive reasoning, and max for the hardest tasks where accuracy is worth extra time and spend.

In this guide, you will build a practical Claude Fable 5 workflow that selects the right effort level for different tasks. You will configure API calls, create a reusable routing function, test output quality, monitor token usage, and troubleshoot common mistakes. By the end, you will know exactly when to use each effort level and how to avoid wasting budget on unnecessary high-effort requests.

Prerequisites: Required Tools, Knowledge, and Setup

Before you begin, prepare the following:

• Claude API access with a valid API key.
• Basic terminal knowledge for running commands with curl.
• Python 3.10+ if you want to run the Python examples.
• Node.js 18+ if you prefer JavaScript examples.
• A clear task list containing simple, medium, complex, and high-stakes prompts.

Set your API key as an environment variable. Do this instead of hardcoding the key into your application because environment variables are easier to rotate and safer to manage.

export ANTHROPIC_API_KEY='your_api_key_here'

Expected result: your terminal stores the API key for the current session. Verify it with:

echo $ANTHROPIC_API_KEY

You should see your key or a masked value, depending on your shell setup.

Warning: never commit API keys to Git. If you accidentally expose a key, revoke it immediately and create a new one.

Step 1: Understand What Claude Fable 5 Effort Levels Control

Start by treating effort as a reasoning and resource control. The higher the effort level, the more work Claude Fable 5 is allowed to do before producing an answer. That usually improves quality on difficult tasks, but it can also increase latency and token usage.

Low Effort

Use low for fast, inexpensive, high-volume work. Choose it for classification, simple extraction, short rewrites, quick chat responses, formatting, and lightweight sub-agent steps.

Example use cases:

• Classify a support ticket as billing, technical, or account-related.
• Rewrite a sentence in a friendlier tone.
• Extract a date, name, or order number from a short message.
• Generate a short social media caption.

Expected result: faster responses and lower cost, with a possible reduction in reasoning depth.

Medium Effort

Use medium for balanced workloads. This is a strong choice for typical production applications where you need reliable quality but cannot justify the cost of high effort for every request.

Example use cases:

• Generate standard application code.
• Summarize a multi-section document.
• Draft customer support replies with policy constraints.
• Run tool-using workflows that include search, retrieval, or database calls.

Expected result: better reasoning than low effort while keeping latency and cost manageable.

High Effort

Use high as your safe default for complex reasoning, nuanced writing, difficult coding, and tasks where quality matters more than response speed. In many implementations, leaving the effort parameter unspecified behaves like high effort.

Example use cases:

• Debug a subtle production issue.
• Compare business strategies with tradeoffs.
• Analyze a long technical document.
• Produce an important executive brief.

Expected result: stronger answers, better synthesis, and more careful reasoning, with higher token use than low or medium.

Max Effort

Use max only when the task is genuinely hard, long-context, or error-sensitive. This setting is best for work where the cost of a bad answer is higher than the cost of additional tokens.

Example use cases:

• Perform a complex architecture review.
• Resolve a difficult multi-file coding problem.
• Synthesize hundreds of pages of context.
• Analyze a high-stakes legal, financial, or compliance draft with human review.

Expected result: maximum reasoning depth and strongest capability ceiling, but also the highest latency and token consumption.

Step 2: Create Your First Claude Fable 5 API Request with an Effort Level

Make a simple request with curl. Start with high because it is the safest baseline for comparing other effort levels.

curl https://api.anthropic.com/v1/messages \
  -H 'x-api-key: '$ANTHROPIC_API_KEY \
  -H 'anthropic-version: 2023-06-01' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-fable-5",
    "max_tokens": 800,
    "effort": "high",
    "messages": [
      {
        "role": "user",
        "content": "Explain how effort levels affect latency, quality, and cost in three concise paragraphs."
      }
    ]
  }'

Why this step is necessary: you need a baseline request before you can compare low, medium, high, and max. High effort gives you a quality-oriented reference point.

Expected result: the API returns a JSON response containing a generated answer. The shape may look similar to this:

{
  "id": "msg_...",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Effort levels control how much reasoning work Claude Fable 5 applies..."
    }
  ],
  "usage": {
    "input_tokens": 35,
    "output_tokens": 180
  }
}

Screenshot description: in an API client such as Postman or Insomnia, you should see the request body on the left and a JSON response on the right. The response should include generated text and token usage metadata.

Step 3: Compare Low, Medium, High, and Max on the Same Prompt

Run the same prompt four times and change only the effort value. This isolates the effect of effort level from other variables.

for effort in low medium high max; do
  echo "\n--- Effort: $effort ---"
  curl -s https://api.anthropic.com/v1/messages \
    -H 'x-api-key: '$ANTHROPIC_API_KEY \
    -H 'anthropic-version: 2023-06-01' \
    -H 'content-type: application/json' \
    -d "{
      \"model\": \"claude-fable-5\",
      \"max_tokens\": 900,
      \"effort\": \"$effort\",
      \"messages\": [
        {
          \"role\": \"user\",
          \"content\": \"Create a migration plan for moving a small monolith to services. Include risks and sequencing.\"
        }
      ]
    }"
done

Why this step is necessary: effort levels are easiest to understand when you compare them against the same task. You will usually see low produce a shorter and more direct answer, while high and max provide more detailed risk analysis and sequencing.

Expected result:

• Low: concise plan, fewer caveats, fastest response.
• Medium: practical plan with reasonable detail.
• High: stronger analysis, better sequencing, clearer tradeoffs.
• Max: most thorough answer, best for difficult architecture planning.

Step 4: Use a Decision Matrix to Select the Right Effort Level

Create a simple rule before you build automation. Do not default every task to max. That increases cost and latency without guaranteeing meaningful improvement on simple prompts.

Expected result: your team has a shared standard for choosing effort levels instead of making arbitrary per-prompt decisions.

Step 5: Implement Effort Routing in Python

Build a small Python client that selects effort based on task type. This pattern saves money because easy tasks use lower effort while hard tasks still get deeper reasoning.

import os
import requests

API_KEY = os.environ["ANTHROPIC_API_KEY"]
API_URL = "https://api.anthropic.com/v1/messages"

EFFORT_BY_TASK = {
    "classification": "low",
    "extraction": "low",
    "standard_summary": "medium",
    "customer_reply": "medium",
    "coding": "high",
    "analysis": "high",
    "architecture_review": "max",
    "long_context_synthesis": "max",
}

def choose_effort(task_type: str) -> str:
    return EFFORT_BY_TASK.get(task_type, "high")

def ask_claude(prompt: str, task_type: str, max_tokens: int = 1000):
    effort = choose_effort(task_type)

    payload = {
        "model": "claude-fable-5",
        "max_tokens": max_tokens,
        "effort": effort,
        "messages": [
            {"role": "user", "content": prompt}
        ]
    }

    response = requests.post(
        API_URL,
        headers={
            "x-api-key": API_KEY,
            "anthropic-version": "2023-06-01",
            "content-type": "application/json",
        },
        json=payload,
        timeout=120,
    )
    response.raise_for_status()
    return response.json()

if __name__ == "__main__":
    result = ask_claude(
        prompt="Classify this message: 'I was charged twice for my subscription.'",
        task_type="classification",
        max_tokens=200,
    )
    print(result["content"][0]["text"])
    print(result.get("usage", {}))

Install the required package and run the file:

pip install requests
python claude_effort_router.py

Why this step is necessary: production systems should not rely on manual effort selection. Routing makes the decision consistent, testable, and cost-aware.

Expected result: the classification request uses low effort and returns a short answer such as:

Billing

You should also see usage metadata printed below the answer.

Step 6: Add Guardrails for Max Effort

Protect your budget by requiring explicit approval before using max. This is especially important in applications where users can submit arbitrary prompts.

def choose_effort_with_guardrails(task_type: str, allow_max: bool = False) -> str:
    effort = EFFORT_BY_TASK.get(task_type, "high")

    if effort == "max" and not allow_max:
        return "high"

    return effort

Use it like this:

effort = choose_effort_with_guardrails("architecture_review", allow_max=False)
print(effort)  # high

effort = choose_effort_with_guardrails("architecture_review", allow_max=True)
print(effort)  # max

Why this step is necessary: max effort can be valuable, but it should be reserved for work that justifies the extra latency and token usage.

Warning: if your application allows Claude to call tools that modify files, send emails, update databases, or execute code, require human confirmation before any destructive action. Higher effort does not eliminate the need for safety controls.

Step 7: Build a JavaScript Helper for Web Applications

If you are building a web app or backend service in Node.js, create a reusable helper that maps task complexity to effort.

const EFFORT_BY_COMPLEXITY = {
  simple: 'low',
  normal: 'medium',
  complex: 'high',
  critical: 'max'
};

function chooseEffort(complexity = 'complex') {
  return EFFORT_BY_COMPLEXITY[complexity] || 'high';
}

async function askClaude({ prompt, complexity = 'complex', maxTokens = 1000 }) {
  const effort = chooseEffort(complexity);

  const response = await fetch('https://api.anthropic.com/v1/messages', {
    method: 'POST',
    headers: {
      'x-api-key': process.env.ANTHROPIC_API_KEY,
      'anthropic-version': '2023-06-01',
      'content-type': 'application/json'
    },
    body: JSON.stringify({
      model: 'claude-fable-5',
      max_tokens: maxTokens,
      effort,
      messages: [
        { role: 'user', content: prompt }
      ]
    })
  });

  if (!response.ok) {
    throw new Error(`Claude API error: ${response.status} ${await response.text()}`);
  }

  return response.json();
}

askClaude({
  prompt: 'Summarize the risks in migrating a payment service to a new provider.',
  complexity: 'complex',
  maxTokens: 800
}).then(result => {
  console.log(result.content[0].text);
  console.log(result.usage);
});

Run it with:

node claude-effort-helper.js

Expected result: the helper sends effort: high for a complex task and prints both the response text and token usage.

Step 8: Monitor Cost, Latency, and Quality

Measure every effort level using three metrics: latency, token usage, and answer quality. Do this before scaling your application because small per-request differences can become expensive at volume.

Add timing to your Python function:

import time

start = time.perf_counter()
result = ask_claude(
    prompt="Write a concise incident summary from these notes: ...",
    task_type="standard_summary",
    max_tokens=600,
)
elapsed = time.perf_counter() - start

print("Elapsed seconds:", round(elapsed, 2))
print("Usage:", result.get("usage", {}))

Why this step is necessary: effort levels are not just quality settings. They affect system performance, user experience, rate limit consumption, and monthly spend.

Expected result: low and medium should generally complete faster than high and max. High and max may produce more detailed outputs on complex prompts.

Screenshot description: in your usage dashboard, look for a graph showing request volume and token consumption by day. After testing max effort, you may see a visible increase in output tokens or total usage.

Step 9: Tune Prompts for Each Effort Level

Do not use the same prompt style for every effort level. Give low effort tasks tight instructions. Give high and max effort tasks enough context and evaluation criteria to use the extra reasoning effectively.

Low Effort Prompt Example

Classify the message into one label: billing, technical, account, other.
Return only the label.

Message: I cannot reset my password.

Expected result:

account

Medium Effort Prompt Example

Summarize the following customer conversation in five bullets.
Include the customer problem, attempted fixes, current status, and recommended next step.

Conversation:
...

Expected result: a structured summary suitable for a support handoff.

High Effort Prompt Example

Review this API design for scalability, security, and developer experience.
Identify the top five issues, explain why each matters, and recommend concrete fixes.

API design:
...

Expected result: a deeper critique with prioritized recommendations.

Max Effort Prompt Example

You are reviewing a proposed migration of a revenue-critical billing system.
Analyze the plan for data integrity, rollback safety, observability, compliance, and customer impact.
Produce:
1. Critical risks
2. Missing requirements
3. Safer migration sequence
4. Test plan
5. Go/no-go checklist

Migration plan:
...

Expected result: a thorough review that justifies using max effort.

Troubleshooting: Common Issues and Solutions

Issue 1: The API Rejects the Effort Value

Cause: the model, endpoint, SDK, or account configuration may not support the specified effort parameter.

Fix: verify the accepted values are exactly low, medium, high, and max. Check your SDK version and update it if needed.

pip install --upgrade requests
npm update

Issue 2: Max Effort Is Too Slow

Cause: max effort is designed for hard tasks and may use more reasoning time.

Fix: route only critical tasks to max. Use high for complex but routine work and medium for normal production requests.

Issue 3: Low Effort Produces Shallow Answers

Cause: the task may require reasoning beyond what low effort is best suited for.

Fix: move the task to medium or high. Also tighten the prompt by adding an output format and success criteria.

Issue 4: Token Usage Is Higher Than Expected

Cause: high and max effort can produce longer answers, especially when prompts request detailed analysis.

Fix: lower max_tokens, request concise output, or use routing rules to reserve expensive effort levels for valuable tasks.

{
  "max_tokens": 400,
  "effort": "medium"
}

Issue 5: The Model Over-Explains Simple Tasks

Cause: the prompt may not restrict the output format.

Fix: instruct the model to return only the required field.

Return only valid JSON with these keys: category, confidence.
Do not include explanation.

Testing: Verify That Your Effort Strategy Works

Test your implementation with a fixed benchmark set. Include simple, normal, complex, and critical tasks. Run each prompt at multiple effort levels and record the results.

test_cases = [
    ("classification", "Classify: 'My invoice is wrong.'"),
    ("standard_summary", "Summarize this meeting transcript: ..."),
    ("analysis", "Compare these two database scaling options: ..."),
    ("architecture_review", "Review this multi-region architecture: ..."),
]

for task_type, prompt in test_cases:
    result = ask_claude(prompt, task_type, max_tokens=800)
    print("Task:", task_type)
    print("Effort:", choose_effort(task_type))
    print("Usage:", result.get("usage", {}))
    print(result["content"][0]["text"][:500])
    print("-" * 80)

Score each response from 1 to 5 on:

• Correctness: does the answer solve the task?
• Completeness: does it include the required details?
• Conciseness: does it avoid unnecessary output?
• Latency: is it fast enough for the user experience?
• Cost: is the token usage acceptable?

Expected result: low should win on speed and cost for simple tasks. Medium should perform well for routine production work. High should be your strongest general-purpose setting. Max should show its value mainly on the hardest prompts.

Next Steps: Extend and Improve Your Effort Workflow

1. Add automatic fallback. If a low-effort answer fails validation, retry once at medium or high.
2. Log effort with every request. Store effort, latency, token usage, task type, and user rating.
3. Create budget limits. Cap max-effort usage per user, workspace, or day.
4. Use prompt templates. Maintain separate templates for low, medium, high, and max effort workflows.
5. Review production samples weekly. Downgrade tasks that do not benefit from high or max effort.

For example, implement a validation-based retry pattern:

def ask_with_retry(prompt: str, task_type: str):
    result = ask_claude(prompt, task_type, max_tokens=600)
    text = result["content"][0]["text"]

    if task_type == "classification" and text.strip().lower() not in {"billing", "technical", "account", "other"}:
        return ask_claude(prompt, "customer_reply", max_tokens=600)

    return result

Why this helps: you keep most requests cheap while escalating only when the first answer fails a measurable requirement.

Conclusion: Use Effort Levels as a Practical Control System

Claude Fable 5 effort levels give you a direct way to balance quality, speed, and cost. Use low for simple and high-volume tasks, medium for balanced everyday workflows, high as the quality-focused default, and max for the most difficult or high-stakes work.

Start with high when you are unsure, then move down to medium or low when the task is routine, structured, or latency-sensitive. Move up to max only when the task complexity justifies the additional token usage. Build routing, monitoring, guardrails, and testing into your application so effort selection becomes a repeatable engineering decision rather than a guess.

The best Claude Fable 5 implementations do not always use the highest setting. They use the right setting at the right time.