effort changedbuild-with-claude/effort
Recorded here
Lines+25added
Lines−294removed
From line
27
where the diff opens
First seen
14 Aug 2026
this site's first read of the page
Recorded edits31to this page, all time
### Per-message effort ### Per-message effort (beta)
The whole hunk
from line 27, old and new numbered
/
from line 27
2727 - claude-opus-4-5-20251101
2828 supportedPlatforms:
2929 Claude API: stable
30 Amazon Bedrock: stable
31 Amazon Bedrock (bedrock-runtime): stable
3032 Claude Platform on AWS: stable
3133 Claude Models on Google Cloud (Anthropic managed): stable
32 Amazon Bedrock: stable
33 Amazon Bedrock (InvokeModel): stable
3434 Claude Models on Google Cloud (Google managed): stable
3535 Microsoft Foundry: stable
3636---
from line 40
4040* **Messages API**: Set `output_config.effort` on the request. With no value, the model’s default level applies.
4141* **Managed Agents**: Set `effort` on the agent’s model object, or in a session’s model override. With no value, Managed Agents fills in the model’s default.
4242
43The effort parameter lets you control how many tokens Claude spends when responding to requests. You can trade off between response thoroughness and token efficiency with a single model. The top-level effort parameter is available on all supported models with no beta header required. [Per-message effort](https://platform.claude.com/docs/en/build-with-claude/effort#change-effort-mid-conversation-beta) is in beta.
43The effort parameter lets you control how many tokens Claude spends when responding to requests. You can trade off between response thoroughness and token efficiency with a single model.
4444
4545<Tip>
4646 To learn how effort interacts with thinking and which control to reach for, see [Thinking and effort](https://platform.claude.com/docs/en/build-with-claude/thinking#thinking-and-effort). Where adaptive thinking is available, effort is the recommended way to control thinking depth.
from line 187
187187 ```
188188
189189 ```php PHP
190 use Anthropic\Client;
191 use Anthropic\Messages\Model;
192 use Anthropic\Messages\TextBlock;
193
190194 $client = new Client();
191195
192196 $message = $client->messages->create(
from line 198
194198 messages: [
195199 ['role' => 'user', 'content' => 'Analyze the trade-offs between microservices and monolithic architectures']
196200 ],
197 model: 'claude-opus-5-5',
201 model: Model::CLAUDE_OPUS_5_5,
198202 outputConfig: ['effort' => 'medium'],
199203 );
200204
201205 foreach ($message->content as $block) {
202 if ($block->type === 'text') {
206 if ($block instanceof TextBlock) {
203207 echo $block->text, PHP_EOL;
204208 }
205209 }
from line 224
220224 )
221225
222226 message.content.each do |block|
223 puts block.text if block.type == :text
227 case block
228 when Anthropic::Models::TextBlock
229 puts block.text
230 end
224231 end
225232 ```
226233</CodeGroup>
from line 272
265272
266273Claude Fable 5.2 supports all five effort levels. The API default is `high`. Adaptive thinking is always on, so effort is your main control for thinking depth, latency, and cost. Start with `high`. Most of the gain in capability is already present at `high`, and above it, gains are uneven and depend on the task. Step up to `xhigh` for your hardest long-running coding and agentic work, where you’ve measured a gain. Step down to `medium` or `low` where your evals show quality holds. Reserve `max` for measuring the model’s ceiling and for the rare task where time and tokens don’t matter. At `max` the model optimizes for capability without regard to token cost. It runs slower and costs more than at `xhigh`, often for only a small gain. Run an effort sweep on your own evals rather than carrying settings over from Claude Fable 5.1. At `high` and above, set a large `max_tokens`. It’s a hard limit on total output (thinking plus response text). Effort barely changes how long the model’s replies are, so use your prompt to change reply length and tone. The same recommendations apply to Claude Mythos 5.2.
267274
268Where your platform supports it, Claude Fable 5.2 and Claude Mythos 5.2 also support [changing effort mid-conversation](https://platform.claude.com/docs/en/build-with-claude/effort#change-effort-mid-conversation-beta) with a per-message `output_config`, which preserves the prompt cache.
275Where your platform supports it, Claude Fable 5.2 and Claude Mythos 5.2 also support [changing effort mid-conversation](https://platform.claude.com/docs/en/build-with-claude/effort-per-message) with a per-message `output_config`, which preserves the prompt cache.
269276
270277See also: [Prompting Claude Fable 5.2](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#calibrate-effort)
271278
272279**[Claude Opus 5.5](https://platform.claude.com/docs/en/models/opus-5-5/overview)** — *For long-running agentic coding and knowledge work*
273280
274Claude Opus 5.5 supports all five effort levels, and `medium` is the default (Claude Opus 5 and earlier Opus models default to `high`, so a request that omits `effort` runs one level lower than it did on Claude Opus 5). Adaptive thinking is always on and can’t be turned off, so effort is the primary control for how much the model reasons and what a request costs. Run an effort sweep on your own evals rather than carrying settings over from an earlier model, and set a large `max_tokens` at the higher levels: it’s a hard limit on total output (thinking plus response text). Requests that set `thinking: {"type": "disabled"}` return a 400 error at every effort level. Claude Opus 5.5 also supports [changing effort mid-conversation](https://platform.claude.com/docs/en/build-with-claude/effort#change-effort-mid-conversation-beta) with a per-message `output_config`, which preserves the prompt cache.
281Claude Opus 5.5 supports all five effort levels, and `medium` is the default (Claude Opus 5 and earlier Opus models default to `high`, so a request that omits `effort` runs one level lower than it did on Claude Opus 5). Adaptive thinking is always on and can’t be turned off, so effort is the primary control for how much the model reasons and what a request costs. Run an effort sweep on your own evals rather than carrying settings over from an earlier model, and set a large `max_tokens` at the higher levels: it’s a hard limit on total output (thinking plus response text). Requests that set `thinking: {"type": "disabled"}` return a 400 error at every effort level. Claude Opus 5.5 also supports [changing effort mid-conversation](https://platform.claude.com/docs/en/build-with-claude/effort-per-message) with a per-message `output_config`, which preserves the prompt cache.
275282
276283See also: [Prompting Claude Opus 5.5](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5-5)
277284
from line 288
281288
282289To turn off up-front thinking, send `thinking: {"type": "between_tools"}` instead of `"disabled"`. It’s the lowest thinking setting on Claude Sonnet 5.5, and it works at `low`, `medium`, and `high` effort. At `xhigh` or `max`, a request with it returns a 400 error, so use adaptive thinking at those levels: omit the `thinking` field or send `thinking: {"type": "adaptive"}`. See [Running without up-front thinking](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking).
283290
284Claude Sonnet 5.5 also supports [changing effort mid-conversation](https://platform.claude.com/docs/en/build-with-claude/effort#change-effort-mid-conversation-beta) with a per-message `output_config`, which preserves the prompt cache. With `between_tools`, effort can’t change mid-conversation: a per-message `output_config.effort` that differs from the level in effect returns a 400 error. To vary effort for each turn, use adaptive thinking.
291Where your platform supports it, Claude Sonnet 5.5 also supports [changing effort mid-conversation](https://platform.claude.com/docs/en/build-with-claude/effort-per-message) with a per-message `output_config`, which preserves the prompt cache. With `between_tools`, effort can’t change mid-conversation: a per-message `output_config.effort` that differs from the level in effect returns a 400 error. To vary effort for each turn, use adaptive thinking.
285292
286293See also: [Prompting Claude Sonnet 5.5](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#calibrate-effort)
287294
from line 298
291298
292299To get less thinking, lower the effort level. You can also send `thinking: {"type": "disabled"}` at `high` effort or below. At `xhigh` or `max`, it returns a 400 error, so use adaptive thinking there: omit the `thinking` field or send `thinking: {"type": "adaptive"}`.
293300
294Where your platform supports it, Claude Haiku 5.5 also lets you [change effort mid-conversation](https://platform.claude.com/docs/en/build-with-claude/effort#change-effort-mid-conversation-beta) with a per-message `output_config`, which preserves the prompt cache. With `thinking: {"type": "disabled"}`, effort can’t change mid-conversation: a per-message `output_config.effort` that differs from the level in effect returns a 400 error. To vary effort for each turn, use adaptive thinking.
301Where your platform supports it, Claude Haiku 5.5 also lets you [change effort mid-conversation](https://platform.claude.com/docs/en/build-with-claude/effort-per-message) with a per-message `output_config`, which preserves the prompt cache. With `thinking: {"type": "disabled"}`, effort can’t change mid-conversation: a per-message `output_config.effort` that differs from the level in effect returns a 400 error. To vary effort for each turn, use adaptive thinking.
295302
296303See also: [Prompting Claude Haiku 5.5](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking)
297304
from line 306
299306
300307Claude Fable 5.1 supports all five effort levels. **Start with `high`, the default.** Step up to `xhigh` or `max` for the most capability-sensitive agentic and coding work, and step down to `medium` or `low` for routine or latency-sensitive work once your evals show quality holds. At `high` and above, set a large `max_tokens`. It’s a hard limit on total output (thinking plus response text).
301308
302Claude Fable 5.1 also supports [changing effort mid-conversation](https://platform.claude.com/docs/en/build-with-claude/effort#change-effort-mid-conversation-beta) with a per-message `output_config`, which preserves the prompt cache.
309Claude Fable 5.1 also supports [changing effort mid-conversation](https://platform.claude.com/docs/en/build-with-claude/effort-per-message) with a per-message `output_config`, which preserves the prompt cache.
303310
304311See also: [Prompting Claude Fable 5.1](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#consider-all-effort-levels)
305312
from line 330
323330
324331When running Claude Opus 5 at `xhigh` or `max` effort, set a large `max_tokens` so the model has room to think and act across subagents and tool calls. Starting at 64k tokens and tuning from there is a reasonable default.
325332
326Claude Opus 5 also supports [changing effort mid-conversation](https://platform.claude.com/docs/en/build-with-claude/effort#change-effort-mid-conversation-beta) with a per-message `output_config`, which preserves the prompt cache. Per-message effort isn’t available for Claude Opus 5 on Amazon Bedrock.
333Where your platform supports it, Claude Opus 5 also supports [changing effort mid-conversation](https://platform.claude.com/docs/en/build-with-claude/effort-per-message) with a per-message `output_config`, which preserves the prompt cache.
327334
328335See also: [Prompting Claude Opus 5](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5)
329336
from line 413
406413
407414## Change effort mid-conversation
408415
409You can run later turns of a conversation at a different effort level in two ways. On Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, and Claude Haiku 5.5, use a per-message effort change, which keeps the prompt cache. On other models, set a new top-level value on the next request, which starts the cache over.
416You can run later turns of a conversation at a different effort level in two ways: a per-message effort change, which keeps the prompt cache, or a new top-level value on the next request, which starts the cache over.
410417
411### Per-message effort (beta)
418### Per-message effort
412419
413Per-message effort is in beta. On the Claude API and [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/en/build-with-claude/claude-models-on-google-cloud/google-managed), it’s available on Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, and Claude Haiku 5.5. On the Claude API, it’s also available on Claude Fable 5.2 and Claude Mythos 5.2. On Claude Models on Google Cloud (Google managed), it’s also available on Claude Fable 5.2 and Claude Mythos 5.2. On [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/en/build-with-claude/claude-models-on-google-cloud/anthropic-managed), it’s available on Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, and Claude Haiku 5.5. On [Claude Platform on AWS](https://platform.claude.com/docs/en/build-with-claude/claude-platform-on-aws), it’s available on Claude Fable 5.2, Claude Fable 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, and Claude Haiku 5.5. On [Amazon Bedrock](https://platform.claude.com/docs/en/build-with-claude/claude-in-amazon-bedrock), it’s available on Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1, Claude Mythos 5.1, and Claude Opus 5.5. It requires the [beta header](https://platform.claude.com/docs/en/api/beta-headers) `mid-conversation-output-config-2026-07-01`. With the Amazon Bedrock [InvokeModel API](https://platform.claude.com/docs/en/build-with-claude/claude-on-amazon-bedrock-legacy), it’s available on Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1, and Claude Opus 5.5, and you send that value in the `anthropic_beta` array of the request body instead.
420[Per-message effort](https://platform.claude.com/docs/en/build-with-claude/effort-per-message) sets a new level with a `system` message in `messages`.
414421
415Without the beta value, a per-message `output_config` returns a 400 error: `messages.N.output_config: Extra inputs are not permitted`, where `N` is the index of the `system` message in `messages`. With the beta value, models without per-message effort, including Claude Fable 5, return a 400 error: `output_config.effort requires a model that supports per-turn effort; this model does not`. On Amazon Bedrock, those models and Claude Opus 5 return the `Extra inputs are not permitted` error instead. On Claude Sonnet 5.5 with `thinking: {"type": "between_tools"}` and on Claude Haiku 5.5 with `thinking: {"type": "disabled"}`, effort can’t change mid-conversation: a per-message `output_config.effort` that differs from the level in effect returns a 400 error. To vary effort for each turn, use adaptive thinking.
416
417Add a `role: "system"` message with empty `content` and the new level in `output_config.effort`. Placed directly after a `user` turn with new input, it sets the level for Claude’s reply to that turn. Placed anywhere else, such as between an `assistant` turn and the next `user` turn as in the following example, it takes effect from the next `user` turn with new input. A `user` turn that holds only `tool_result` blocks doesn’t count as new input, so a change placed after one in a tool-use loop waits for the next `user` turn with new input. The new level then holds until a later message changes it. Everything before that message is unchanged, so the cached prefix still matches.
418
419The following example starts at `high`, then drops to `low` for a routine follow-up:
420
421<CodeGroup>
422 ```bash cURL
423 # Effort-only system message: the new level takes effect from the next user turn.
424 curl https://api.anthropic.com/v1/messages \
425 -H "x-api-key: $ANTHROPIC_API_KEY" \
426 -H "anthropic-version: 2026-10-21" \
427 -H "anthropic-beta: mid-conversation-output-config-2026-07-01" \
428 -H "content-type: application/json" \
429 -d '{
430 "model": "claude-fable-5-1",
431 "max_tokens": 4096,
432 "output_config": {"effort": "high"},
433 "messages": [
434 {"role": "user", "content": "Plan a migration from SQLite to PostgreSQL in three short steps."},
435 {"role": "assistant", "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
436 {"role": "system", "content": [], "output_config": {"effort": "low"}},
437 {"role": "user", "content": "Summarize the plan in one sentence."}
438 ]
439 }'
440 ```
441
442 ```bash CLI
443 ant beta:messages create \
444 --beta mid-conversation-output-config-2026-07-01 <<'YAML'
445 model: claude-fable-5-1
446 max_tokens: 4096
447 output_config:
448 effort: high
449 messages:
450 - role: user
451 content: Plan a migration from SQLite to PostgreSQL in three short steps.
452 - role: assistant
453 content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
454 # Effort-only system message: the new level takes effect from the next user turn.
455 - role: system
456 content: []
457 output_config:
458 effort: low
459 - role: user
460 content: Summarize the plan in one sentence.
461 YAML
462 ```
463
464 ```python Python
465 client = anthropic.Anthropic()
466
467 response = client.beta.messages.create(
468 model="claude-fable-5-1",
469 max_tokens=4096,
470 output_config={"effort": "high"},
471 messages=[
472 {
473 "role": "user",
474 "content": "Plan a migration from SQLite to PostgreSQL in three short steps.",
475 },
476 {
477 "role": "assistant",
478 "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.",
479 },
480 # Effort-only system message: the new level takes effect from the next user turn.
481 {"role": "system", "content": [], "output_config": {"effort": "low"}},
482 {"role": "user", "content": "Summarize the plan in one sentence."},
483 ],
484 betas=["mid-conversation-output-config-2026-07-01"],
485 )
486
487 for block in response.content:
488 if block.type == "text":
489 print(block.text)
490 ```
491
492 ```typescript TypeScript
493 const client = new Anthropic();
494
495 const response = await client.beta.messages.create({
496 model: "claude-fable-5-1",
497 max_tokens: 4096,
498 output_config: { effort: "high" },
499 messages: [
500 {
501 role: "user",
502 content: "Plan a migration from SQLite to PostgreSQL in three short steps."
503 },
504 {
505 role: "assistant",
506 content:
507 "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
508 },
509 // Effort-only system message: the new level takes effect from the next user turn.
510 { role: "system", content: [], output_config: { effort: "low" } },
511 { role: "user", content: "Summarize the plan in one sentence." }
512 ],
513 betas: ["mid-conversation-output-config-2026-07-01"]
514 });
515
516 for (const block of response.content) {
517 if (block.type === "text") {
518 console.log(block.text);
519 }
520 }
521 ```
522
523 ```csharp C#
524 using Anthropic.Models.Beta;
525 using Anthropic.Models.Beta.Messages;
526 using Model = Anthropic.Models.Messages.Model;
527
528 AnthropicClient client = new();
529
530 var response = await client.Beta.Messages.Create(new MessageCreateParams
531 {
532 Model = Model.ClaudeFable5_1,
533 MaxTokens = 4096,
534 OutputConfig = new() { Effort = Effort.High },
535 Messages =
536 [
537 new BetaUserMessageParam { Content = "Plan a migration from SQLite to PostgreSQL in three short steps." },
538 new BetaAssistantMessageParam { Content = "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts." },
539 // Effort-only system message: the new level takes effect from the next user turn.
540 new BetaSystemMessageParam
541 {
542 Content = new([]),
543 OutputConfig = new() { Effort = BetaSystemMessageOutputConfigEffort.Low },
544 },
545 new BetaUserMessageParam { Content = "Summarize the plan in one sentence." },
546 ],
547 Betas = [AnthropicBeta.MidConversationOutputConfig2026_07_01],
548 });
549
550 foreach (var block in response.Content)
551 {
552 if (block.TryPickText(out var textBlock))
553 {
554 Console.WriteLine(textBlock.Text);
555 }
556 }
557 ```
558
559 ```go Go
560 client := anthropic.NewClient()
561
562 response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
563 Model: anthropic.ModelClaudeFable5_1,
564 MaxTokens: 4096,
565 OutputConfig: anthropic.BetaOutputConfigParam{
566 Effort: anthropic.BetaOutputConfigEffortHigh,
567 },
568 Messages: []anthropic.BetaMessageParam{
569 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Plan a migration from SQLite to PostgreSQL in three short steps.")),
570 {OfAssistant: &anthropic.BetaAssistantMessageParam{
571 Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")},
572 }},
573 // Effort-only system message: the new level takes effect from the next user turn.
574 anthropic.NewBetaSystemMessage(anthropic.BetaSystemMessageOutputConfigParam{
575 Effort: anthropic.BetaSystemMessageOutputConfigEffortLow,
576 }),
577 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Summarize the plan in one sentence.")),
578 },
579 Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMidConversationOutputConfig2026_07_01},
580 })
581 if err != nil {
582 log.Fatal(err)
583 }
584
585 for _, block := range response.Content {
586 if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
587 fmt.Println(textBlock.Text)
588 }
589 }
590 ```
591
592 ```java Java
593 import com.anthropic.models.beta.AnthropicBeta;
594 import com.anthropic.models.beta.messages.BetaMessage;
595 import com.anthropic.models.beta.messages.BetaOutputConfig;
596 import com.anthropic.models.beta.messages.BetaSystemMessageOutputConfig;
597 import com.anthropic.models.beta.messages.BetaSystemMessageParam;
598 import com.anthropic.models.beta.messages.MessageCreateParams;
599 import com.anthropic.models.messages.Model;
600
601 void main() {
602 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
603
604 MessageCreateParams params = MessageCreateParams.builder()
605 .model(Model.CLAUDE_FABLE_5_1)
606 .maxTokens(4096L)
607 .addBeta(AnthropicBeta.MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01)
608 .outputConfig(BetaOutputConfig.builder()
609 .effort(BetaOutputConfig.Effort.HIGH)
610 .build())
611 .addUserMessage("Plan a migration from SQLite to PostgreSQL in three short steps.")
612 .addAssistantMessage("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")
613 // Effort-only system message: the new level takes effect from the next user turn.
614 .addMessage(BetaSystemMessageParam.builder()
615 .contentOfBlocks(List.of())
616 .outputConfig(BetaSystemMessageOutputConfig.builder()
617 .effort(BetaSystemMessageOutputConfig.Effort.LOW)
618 .build())
619 .build())
620 .addUserMessage("Summarize the plan in one sentence.")
621 .build();
622
623 BetaMessage response = client.beta().messages().create(params);
624 response.content().stream()
625 .flatMap(block -> block.text().stream())
626 .forEach(textBlock -> IO.println(textBlock.text()));
627 }
628 ```
629
630 ```php PHP
631 use Anthropic\Beta\AnthropicBeta;
632 use Anthropic\Beta\Messages\BetaMessageParam;
633 use Anthropic\Beta\Messages\BetaOutputConfig;
634 use Anthropic\Beta\Messages\BetaSystemMessageOutputConfig;
635 use Anthropic\Client;
636
637 $client = new Client();
638
639 $response = $client->beta->messages->create(
640 model: 'claude-fable-5-1',
641 maxTokens: 4096,
642 outputConfig: BetaOutputConfig::with(effort: 'high'),
643 messages: [
644 BetaMessageParam::with(role: 'user', content: 'Plan a migration from SQLite to PostgreSQL in three short steps.'),
645 BetaMessageParam::with(role: 'assistant', content: '1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.'),
646 // Effort-only system message: the new level takes effect from the next user turn.
647 BetaMessageParam::with(
648 role: 'system',
649 content: [],
650 outputConfig: BetaSystemMessageOutputConfig::with(effort: 'low'),
651 ),
652 BetaMessageParam::with(role: 'user', content: 'Summarize the plan in one sentence.'),
653 ],
654 betas: [AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01],
655 );
656
657 foreach ($response->content as $block) {
658 if ($block->type === 'text') {
659 echo $block->text, PHP_EOL;
660 }
661 }
662 ```
663
664 ```ruby Ruby
665 client = Anthropic::Client.new
666
667 response = client.beta.messages.create(
668 model: Anthropic::Model::CLAUDE_FABLE_5_1,
669 max_tokens: 4096,
670 output_config: {effort: :high},
671 messages: [
672 {role: "user", content: "Plan a migration from SQLite to PostgreSQL in three short steps."},
673 {role: "assistant", content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
674 # Effort-only system message: the new level takes effect from the next user turn.
675 {role: "system", content: [], output_config: {effort: :low}},
676 {role: "user", content: "Summarize the plan in one sentence."}
677 ],
678 betas: [Anthropic::AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01]
679 )
680
681 response.content.each do |block|
682 puts block.text if block.type == :text
683 end
684 ```
685</CodeGroup>
686
687An effort-only system message carries no text, so the [placement rules for mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages#limitations) don’t apply. It can appear anywhere in `messages`, including as the first entry or between an `assistant` turn and the next `user` turn. Values are the level names (`low`, `medium`, `high`, `xhigh`, and `max`).
688
689Prefer this form over changing the top-level value between requests. A top-level change restarts the cache and, on Claude Fable 5.1, also steers the model less reliably: its earlier replies were written at the previous level, and it tends to stay consistent with them.
690
691422### Top-level effort on the next request
692423
693424The top-level `output_config.effort` applies to the whole request. To run a later part of a conversation at a different level, set the new value on the next request. Because top-level effort shapes the rendered prompt, changing it between requests doesn’t preserve cached prefixes from earlier turns. If you rely on [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) across a long session and your model doesn’t support per-message effort, pick an effort level at the start and keep it constant.
from line 429
6984292. **Use low for speed-sensitive or simple tasks:** When latency matters or tasks are straightforward, low effort can significantly reduce response times and costs.
6994303. **Test your use case:** The impact of effort levels varies by task type. Evaluate performance on your specific use cases before deploying.
7004314. **Consider dynamic effort:** Adjust effort based on task complexity. Simple queries might warrant low effort, whereas agentic coding and complex reasoning benefit from high effort. See the next item before varying it within one conversation.
7015. **Hold top-level effort constant within cached conversations:** Changing the top-level effort value between requests invalidates [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching), so vary it across workloads rather than within a conversation that relies on cache hits. On models that support it, use a [per-message effort change](https://platform.claude.com/docs/en/build-with-claude/effort#change-effort-mid-conversation-beta) instead, which preserves the cache. See [Thinking and prompt caching](https://platform.claude.com/docs/en/build-with-claude/thinking#thinking-and-prompt-caching).
4325. **Hold top-level effort constant within cached conversations:** Changing the top-level effort value between requests invalidates [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching), so vary it across workloads rather than within a conversation that relies on cache hits. On models that support it, use a [per-message effort](https://platform.claude.com/docs/en/build-with-claude/effort-per-message) change instead, which preserves the cache. See [Thinking and prompt caching](https://platform.claude.com/docs/en/build-with-claude/thinking#thinking-and-prompt-caching).
702433
703434## Next steps
704435
No line in this hunk matches that.