LangChain just did something quietly useful and quietly dangerous. As of langchain-core 1.5.0, shipped July 21, 2026, reasoning_effort is a standard chat-model parameter. One string — minimal, low, medium, or high — now sets how hard a reasoning model thinks, and you write it the same way whether the model behind it is GPT, Claude, a Grok model on xAI, or something served by Fireworks.

That's the useful part. The dangerous part is that the parameter is portable but not equivalent. LangChain standardized the dial, not the physics behind it — and if you don't know how each provider interprets the string, the identical line of code can quietly cost you very different amounts of money.

The one knob#

The point of the feature is that this now works across providers without per-vendor code:

from langchain.chat_models import init_chat_model

# Same parameter, four backends
gpt    = init_chat_model("openai:gpt-5.6",        reasoning_effort="low")
claude = init_chat_model("anthropic:claude-opus-4-8", reasoning_effort="low")
grok   = init_chat_model("xai:grok-code",         reasoning_effort="low")

You can also supply it per call instead of at construction, so a cheap extraction step and an expensive planning step can share the same model object at different efforts. Provider support landed in langchain-openai 1.4.0, langchain-xai 1.3.0, and langchain-fireworks 1.5.0; Anthropic joined in langchain-anthropic 1.5.3.

Where it stops being the same knob#

Here's what the abstraction hides. reasoning_effort="medium" does not mean one thing.

On OpenAI, LangChain passes the label straight through to the provider's own discrete reasoning_effort levels. medium is a fixed internal gear — the model decides how much deliberation that label buys. It does not scale with anything you set.

On Anthropic, the same string is converted into a thinking-token budget. Per langchain-anthropic's reference, the adapter multiplies your max_tokens by an effort ratio — roughly 0.1 for minimal, 0.2 for low, 0.5 for medium, 0.8 for high — and clamps the result between 1,024 and 128,000 tokens. Two consequences fall straight out of that formula:

So this line —

resp = claude.invoke(messages, reasoning_effort="medium")

— is not "a medium amount of reasoning." It's "spend up to half of max_tokens on hidden thinking, billed at the output rate." Flip the same code to gpt and medium becomes a coarse discrete setting that ignores max_tokens entirely. Same string, different machine.

LangChain standardized the interface, not the unit. reasoning_effort='medium' is a gear on one provider and a percentage of your token budget on another.

xAI and Fireworks add their own interpretations — xAI places the value in its provider-specific request body, Fireworks passes it to the served model — so the safe assumption is that no two backends price medium the same way.

How to use it without getting billed for the abstraction#

The parameter is worth adopting. It deletes a pile of per-provider glue and makes effort a first-class, swappable setting. Three rules keep it from biting:

  1. Set it per model, not once globally. A single app-wide reasoning_effort="medium" is a cheap knob on one backend and an expensive thinking budget on another. Choose the value per routed model, the way you already tune temperature per provider.
  2. Re-measure when you switch providers. Because the value isn't a shared unit, the only honest comparison is your own eval measuring cost-per-completed-task — not a leaderboard, and not the assumption that low saves the same fraction everywhere. If you route across vendors through a gateway, this is the setting most likely to surprise your invoice.
  3. Watch max_tokens on Anthropic. Since the thinking budget is a fraction of max_tokens, raising your output cap for a long answer also raises the thinking allowance. If you want a big answer but modest reasoning, set the effort down explicitly rather than trusting the default.

And the oldest rule still holds under the new interface: more thinking is not monotonically better. The standard parameter makes it trivially easy to crank effort across every call — which is exactly the reflex to resist. Start low, raise only while your eval shows accuracy climbing against the added cost and latency. We laid out where that curve peaks, and where longer reasoning actively hurts, in Reasoning Effort vs. Thinking Budget.

LangChain gave you one dial for four engines. That's a real convenience. Just remember that the number on the dial doesn't mean the same thing to any two of them.