Effort

ant messages create \
  --model claude-opus-5-5 \
  --max-tokens 4096 \
  --output-config '{effort: medium}' \
  --message '{role: user, content: "Analyze the trade-offs between microservices and monolithic architectures"}' \
  --transform 'content.#(type=="text").text' \
  --raw-output

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Analyze the trade-offs between microservices and monolithic architectures",
        }
    ],
    output_config={"effort": "medium"},
)

for block in response.content:
    if block.type == "text":
        print(block.text)

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 4096,
  messages: [
    {
      role: "user",
      content: "Analyze the trade-offs between microservices and monolithic architectures"
    }
  ],
  output_config: {
    effort: "medium"
  }
});

const textBlock = response.content.find(
  (block): block is Anthropic.TextBlock => block.type === "text"
);
console.log(textBlock?.text);

AnthropicClient client = new();

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 4096,
    Messages = [
        new() {
            Role = Role.User,
            Content = "Analyze the trade-offs between microservices and monolithic architectures"
        }
    ],
    OutputConfig = new OutputConfig
    {
        Effort = Effort.Medium
    }
};

var message = await client.Messages.Create(parameters);
Console.WriteLine(message);

client := anthropic.NewClient()

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 4096,
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze the trade-offs between microservices and monolithic architectures")),
	},
	OutputConfig: anthropic.OutputConfigParam{
		Effort: anthropic.OutputConfigEffortMedium,
	},
})
if err != nil {
	log.Fatal(err)
}
for _, block := range response.Content {
	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
		fmt.Println(textBlock.Text)
	}
}

import com.anthropic.models.messages.OutputConfig;

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(4096L)
        .addUserMessage("Analyze the trade-offs between microservices and monolithic architectures")
        .outputConfig(OutputConfig.builder()
            .effort(OutputConfig.Effort.MEDIUM)
            .build())
        .build();

    Message response = client.messages().create(params);
    response.content().stream()
        .flatMap(block -> block.text().stream())
        .forEach(textBlock -> IO.println(textBlock.text()));
}

$client = new Client();

$message = $client->messages->create(
    maxTokens: 4096,
    messages: [
        ['role' => 'user', 'content' => 'Analyze the trade-offs between microservices and monolithic architectures']
    ],
    model: 'claude-opus-5-5',
    outputConfig: ['effort' => 'medium'],
);

foreach ($message->content as $block) {
    if ($block->type === 'text') {
        echo $block->text, PHP_EOL;
    }
}

client = Anthropic::Client.new

message = client.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 4096,
  messages: [
    { role: "user", content: "Analyze the trade-offs between microservices and monolithic architectures" }
  ],
  output_config: {
    effort: "medium"
  }
)

message.content.each do |block|
  puts block.text if block.type == :text
end

ant beta:messages create --beta mid-conversation-output-config-2026-07-01 \
  --transform 'content.#(type=="text").text' --raw-output <<'YAML'
model: claude-fable-5-1
max_tokens: 4096
output_config:
  effort: high
messages:
  - role: user
    content: Plan a migration from SQLite to PostgreSQL in three short steps.
  - role: assistant
    content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
  # Effort-only system message: the new level takes effect from the next user turn.
  - role: system
    content: []
    output_config:
      effort: low
  - role: user
    content: Summarize the plan in one sentence.
YAML

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-fable-5-1",
    max_tokens=4096,
    output_config={"effort": "high"},
    messages=[
        {
            "role": "user",
            "content": "Plan a migration from SQLite to PostgreSQL in three short steps.",
        },
        {
            "role": "assistant",
            "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.",
        },
        # Effort-only system message: the new level takes effect from the next user turn.
        {"role": "system", "content": [], "output_config": {"effort": "low"}},
        {"role": "user", "content": "Summarize the plan in one sentence."},
    ],
    betas=["mid-conversation-output-config-2026-07-01"],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

const client = new Anthropic();

const response = await client.beta.messages.create({
  model: "claude-fable-5-1",
  max_tokens: 4096,
  output_config: { effort: "high" },
  messages: [
    {
      role: "user",
      content: "Plan a migration from SQLite to PostgreSQL in three short steps."
    },
    {
      role: "assistant",
      content:
        "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
    },
    // Effort-only system message: the new level takes effect from the next user turn.
    { role: "system", content: [], output_config: { effort: "low" } },
    { role: "user", content: "Summarize the plan in one sentence." }
  ],
  betas: ["mid-conversation-output-config-2026-07-01"]
});

for (const block of response.content) {
  if (block.type === "text") {
    console.log(block.text);
  }
}

using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;

AnthropicClient client = new();

var response = await client.Beta.Messages.Create(new MessageCreateParams
{
    Model = "claude-fable-5-1",
    MaxTokens = 4096,
    OutputConfig = new() { Effort = Effort.High },
    Messages =
    [
        new() { Role = Role.User, Content = "Plan a migration from SQLite to PostgreSQL in three short steps." },
        new() { Role = Role.Assistant, Content = "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts." },
        // Effort-only system message: the new level takes effect from the next user turn.
        new()
        {
            Role = Role.System,
            Content = new([]),
            OutputConfig = new() { Effort = BetaSystemMessageOutputConfigEffort.Low },
        },
        new() { Role = Role.User, Content = "Summarize the plan in one sentence." },
    ],
    Betas = [AnthropicBeta.MidConversationOutputConfig2026_07_01],
});

foreach (var block in response.Content)
{
    if (block.TryPickText(out var textBlock))
    {
        Console.WriteLine(textBlock.Text);
    }
}

client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
	Model:     "claude-fable-5-1",
	MaxTokens: 4096,
	OutputConfig: anthropic.BetaOutputConfigParam{
		Effort: anthropic.BetaOutputConfigEffortHigh,
	},
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Plan a migration from SQLite to PostgreSQL in three short steps.")),
		{
			Role:    anthropic.BetaMessageParamRoleAssistant,
			Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")},
		},
		// Effort-only system message: the new level takes effect from the next user turn.
		anthropic.NewBetaSystemMessage(anthropic.BetaSystemMessageOutputConfigParam{
			Effort: anthropic.BetaSystemMessageOutputConfigEffortLow,
		}),
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Summarize the plan in one sentence.")),
	},
	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMidConversationOutputConfig2026_07_01},
})
if err != nil {
	log.Fatal(err)
}

for _, block := range response.Content {
	if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
		fmt.Println(textBlock.Text)
	}
}

import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaMessageParam;
import com.anthropic.models.beta.messages.BetaOutputConfig;
import com.anthropic.models.beta.messages.BetaSystemMessageOutputConfig;
import com.anthropic.models.beta.messages.MessageCreateParams;

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    MessageCreateParams params = MessageCreateParams.builder()
        .model("claude-fable-5-1")
        .maxTokens(4096L)
        .addBeta(AnthropicBeta.MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01)
        .outputConfig(BetaOutputConfig.builder()
            .effort(BetaOutputConfig.Effort.HIGH)
            .build())
        .addUserMessage("Plan a migration from SQLite to PostgreSQL in three short steps.")
        .addAssistantMessage("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")
        // Effort-only system message: the new level takes effect from the next user turn.
        .addMessage(BetaMessageParam.builder()
            .role(BetaMessageParam.Role.SYSTEM)
            .contentOfBetaContentBlockParams(List.of())
            .outputConfig(BetaSystemMessageOutputConfig.builder()
                .effort(BetaSystemMessageOutputConfig.Effort.LOW)
                .build())
            .build())
        .addUserMessage("Summarize the plan in one sentence.")
        .build();

    BetaMessage response = client.beta().messages().create(params);
    response.content().stream()
        .flatMap(block -> block.text().stream())
        .forEach(textBlock -> IO.println(textBlock.text()));
}

use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaMessageParam;
use Anthropic\Beta\Messages\BetaOutputConfig;
use Anthropic\Beta\Messages\BetaSystemMessageOutputConfig;
use Anthropic\Client;

$client = new Client();

$response = $client->beta->messages->create(
    model: 'claude-fable-5-1',
    maxTokens: 4096,
    outputConfig: BetaOutputConfig::with(effort: 'high'),
    messages: [
        BetaMessageParam::with(role: 'user', content: 'Plan a migration from SQLite to PostgreSQL in three short steps.'),
        BetaMessageParam::with(role: 'assistant', content: '1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.'),
        // Effort-only system message: the new level takes effect from the next user turn.
        BetaMessageParam::with(
            role: 'system',
            content: [],
            outputConfig: BetaSystemMessageOutputConfig::with(effort: 'low'),
        ),
        BetaMessageParam::with(role: 'user', content: 'Summarize the plan in one sentence.'),
    ],
    betas: [AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01],
);

foreach ($response->content as $block) {
    if ($block->type === 'text') {
        echo $block->text, PHP_EOL;
    }
}

client = Anthropic::Client.new

response = client.beta.messages.create(
  model: "claude-fable-5-1",
  max_tokens: 4096,
  output_config: {effort: :high},
  messages: [
    {role: "user", content: "Plan a migration from SQLite to PostgreSQL in three short steps."},
    {role: "assistant", content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
    # Effort-only system message: the new level takes effect from the next user turn.
    {role: "system", content: [], output_config: {effort: :low}},
    {role: "user", content: "Summarize the plan in one sentence."}
  ],
  betas: [Anthropic::AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01]
)

response.content.each do |block|
  puts block.text if block.type == :text
end