Muse Spark Open reasoning_effort: levels and cost

Short answer: four levels, no off switch, a high effort by default

LLMTR (llmtr.com) is a gateway that gives access to language models from many providers through one OpenAI-compatible API. On Muse Spark Open (meta/muse-spark-open) you choose the reasoning level with the reasoning_effort field of a /v1/chat/completions request at https://llmtr.com/v1: low, medium, high or xhigh.

The model reasons before every answer, and this cannot be turned off. According to Meta's model card, the level controls how much the model thinks before it responds. Reasoning tokens are counted inside completion_tokens and billed at the output price of $4.25 per 1M tokens, so choosing a level is also choosing a cost.

• Meta, Muse Spark Open model card · 2026-10-17

How do you choose reasoning_effort on Muse Spark Open?

Meta's model card recommends high or xhigh for complex problem solving, coding and agentic tasks, and low or medium for faster, shorter responses. In practice, start with low for classification, format conversion, short summaries and image descriptions, and try high or xhigh for multi-step debugging, planning changes across a codebase and long tool chains. medium is a starting point for work that falls between the two. In agent loops every step is a separate request, so you can vary the level by the kind of step: low for short decisions such as picking a tool, high for a planning step.

The most reliable approach is to take a small sample of your own prompts and try the levels side by side. The Python example below sends the same question at all four levels and prints finish_reason, completion_tokens and the reasoning tokens (usage.completion_tokens_details.reasoning_tokens) for each response. It sends four separate requests, and each one is billed. If the answer is good enough at a low level, stay there; raise the level only when the answer falls short.

A Python example that sends the same question at low, medium, high and xhigh and prints the reasoning tokens of each response.

import os

from openai import OpenAI

client = OpenAI(base_url="https://llmtr.com/v1", api_key=os.environ["LLMTR_API_KEY"])

question = "A train leaves at 09:40 and arrives at 13:05. How long is the trip?"

for effort in ["low", "medium", "high", "xhigh"]:
    response = client.chat.completions.create(
        model="meta/muse-spark-open",
        reasoning_effort=effort,
        max_tokens=8192,
        messages=[{"role": "user", "content": question}],
    )
    usage = response.usage
    details = usage.completion_tokens_details
    reasoning_tokens = details.reasoning_tokens if details else None
    print(effort, response.choices[0].finish_reason, usage.completion_tokens, reasoning_tokens)
    print(response.choices[0].message.content)

How are reasoning tokens billed?

Muse Spark Open costs $1.25 per 1M tokens for input, $0.15 for input read from cache and $4.25 for output. Reasoning is not a separate price line: reasoning tokens sit inside completion_tokens and are billed at the same output price as the visible answer. The usage.completion_tokens_details.reasoning_tokens field in the response shows how much of that total was reasoning. The cache discount applies only to the input side; reasoning tokens are always billed at the output price.

Every 1,000 reasoning tokens add $0.00425 to a request. A worked example: take a 2,000-token prompt and a 400-token visible answer. If the model reasons for 600 tokens, the cost is (2,000 x $1.25 + 1,000 x $4.25) / 1M = $0.00675; if it reasons for 4,000 tokens, it is (2,000 x $1.25 + 4,400 x $4.25) / 1M = $0.0212. With the same prompt and an answer of the same length, the whole difference comes from reasoning. The token counts are examples; the real number depends on the question and the level.

Ways to send the level, and the default

You can give the level in three ways: the reasoning_effort field, a suffix on the model id (meta/muse-spark-open:low, :medium, :high or :xhigh), or the effort field of a reasoning object. When more than one arrives in the same request, the order of precedence is reasoning_effort, then reasoning.effort, then the suffix. The suffix helps in a client where you can change only the model name.

If you send neither the field nor a suffix, the request goes out without a level and the model reasons at its own default, a high effort; Meta's model card names that default as xhigh. Requests that do not state a level therefore run at a high reasoning cost. If cost matters to you, write the level explicitly on every request. These four levels apply to Muse Spark Open; the Muse Spark 1.x models are separate models with their own level sets.

Refused values: none, minimal and attempts to turn reasoning off

The model takes no value outside the four levels. none and minimal return 400 invalid_request, whether sent as the field or as a suffix, and the error message lists the four accepted levels. max, on the other hand, is not refused; it is applied as the highest level, xhigh. An undefined value or an undefined suffix also returns 400.

Attempts to turn reasoning off are refused too: a request that sends "reasoning": false or "reasoning": {"enabled": false} returns 400, and the message tells you to set reasoning_effort to low for the least reasoning. That way a request that believes it switched reasoning off does not silently run, and get billed, at the high default. include_reasoning is not supported on this model; the reasoning trace arrives in reasoning_content in the response and in delta.reasoning_content when streaming.

How the max_tokens budget, the cache and the level interact

Reasoning tokens also come out of the max_tokens budget. If the budget is too small for the reasoning, the response ends with finish_reason: length before it is complete; in that case raise max_tokens or pick a lower level. At the higher levels, keep max_tokens above a few thousand tokens. The context window is 1,048,576 tokens, and the prompt and max_tokens both count against it.

A long, repeated system prompt does not change the reasoning cost, but it can lower the input side: tokens read from cache are billed at $0.15 per 1M tokens and show up in usage.prompt_tokens_details.cached_tokens. A hit is not guaranteed. To get started, create an account at llmtr.com, top up your balance under Dashboard > Billing and create a key under Dashboard > API Keys.

Choose reasoning_effort on Muse Spark Open

Pick a sample of your own prompts, try meta/muse-spark-open at all four levels and fix the lowest level whose answer is good enough.

1. Pick sample prompts. Choose a few prompts that represent your real work and note the answer you expect.
2. Try the four levels. Send each prompt to https://llmtr.com/v1/chat/completions with reasoning_effort low, medium, high and xhigh; record the answer and usage.completion_tokens_details.reasoning_tokens.
3. Fix the level. Pick the lowest level whose answer is good enough and send reasoning_effort explicitly on every request in your application.

Frequently asked questions

What is the default reasoning_effort on Muse Spark Open?

Without the field the model reasons at a high effort; Meta's model card names the default as xhigh. Send low or medium for shorter, cheaper replies.

Can reasoning be turned off on Muse Spark Open?

No. none, minimal, reasoning: false and reasoning: {enabled: false} return 400. For the least reasoning, set reasoning_effort to low.

How are reasoning tokens billed on Muse Spark Open?

They are counted inside completion_tokens and billed at the output price of $4.25 per 1M tokens. Every 1,000 reasoning tokens cost $0.00425.

Related posts

• Muse Spark Open API: OpenAI SDK usage and pricing
• Send images, video and audio to Muse Spark Open
• Models added to LLMTR in October 2026: facts and guide

• Muse Spark Open model
• Muse Spark Open documentation
• Reasoning effort documentation
• Pricing