Effort · LHQ 的网络日志

API 支持：用法因产品而异。

Messages API：始终开启。在请求中设置 output_config.effort。未设置值时，采用模型的默认级别。
Managed Agents：始终开启。在智能体的模型对象上或会话的模型覆盖中设置 effort。未设置值时，Managed Agents 会填入模型的默认值。

effort 参数让您可以控制 Claude 在响应请求时花费的令牌数量。您可以在单个模型上权衡响应的全面性与令牌效率。顶层 effort 参数在所有受支持的模型上均可使用，无需 beta 标头。按消息设置 effort目前处于 beta 阶段。

提示

要了解 effort 如何与思考相互作用以及应该使用哪种控制方式，请参阅思考与努力程度。在可使用自适应思考的情况下，effort 是控制思考深度的推荐方式。

设置 effort 级别

在请求中设置 output_config.effort。以下示例以 medium 努力程度运行一个请求。

cURL

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-opus-5-5",
    "max_tokens": 4096,
    "messages": [{
      "role": "user",
      "content": "Analyze the trade-offs between microservices and monolithic architectures"
    }],
    "output_config": {
      "effort": "medium"
    }
  }'

CLI

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"}'

Python

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)

TypeScript

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.type === "text");
console.log(textBlock?.text);

AnthropicClient client = new();

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 4096,
    Messages = [
        new UserMessageParam
        {
            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)
	}
}

Java

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()));
}

PHP

$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;
    }
}

Ruby

client = Anthropic::Client.new

message = client.messages.create(
  model: Anthropic::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

effort 的工作原理

大多数 Claude 模型默认使用高努力程度，会根据需要花费尽可能多的令牌以获得出色的结果；Claude Opus 5.5 和 Claude Haiku 5.5 默认使用 medium。您可以将努力程度提高到 max 以获得绝对最高的能力，也可以降低努力程度以更节省令牌用量，在接受一定能力下降的同时优化速度和成本。

提示

将 effort 设置为模型的默认值（Claude Opus 5.5 和 Claude Haiku 5.5 上为 "medium"，其他模型上为 "high"）与完全省略 effort 参数的行为完全相同。

effort 参数影响响应中的所有令牌，包括：

文本响应和解释
工具调用和函数参数
思考（启用时）

由于 effort 适用于每个输出令牌，因此无论是否启用思考它都能发挥作用。较低的努力程度也意味着更少、更简洁的工具调用。

effort 级别

级别	描述	典型用例
`max`	绝对最高能力，对令牌花费没有任何限制。适用于 Claude Fable 5.1、Claude Mythos 5.1、Claude Fable 5、Claude Mythos 5、Claude Mythos Preview、Claude Opus 5.5、Claude Opus 5、Claude Opus 4.8、Claude Opus 4.7、Claude Opus 4.6、Claude Sonnet 5.5、Claude Sonnet 5、Claude Sonnet 4.6 和 Claude Haiku 5.5。	需要最深入推理和最全面分析的任务
`xhigh`	面向长周期工作的扩展能力。适用于 Claude Fable 5.1、Claude Mythos 5.1、Claude Fable 5、Claude Mythos 5、Claude Opus 5.5、Claude Opus 5、Claude Opus 4.8、Claude Opus 4.7、Claude Sonnet 5.5、Claude Sonnet 5 和 Claude Haiku 5.5。	令牌预算达数百万的长时间运行（超过 30 分钟）的智能体和编码任务
`high`	根据任务需要花费尽可能多的令牌以获得出色的结果。是除 Claude Opus 5.5 和 Claude Haiku 5.5 之外所有支持 effort 的模型的默认值。	复杂推理、困难的编码问题、智能体任务
`medium`	均衡的方法，可适度节省令牌。是 Claude Opus 5.5 和 Claude Haiku 5.5 的默认值。	需要在速度、成本和性能之间取得平衡的智能体任务
`low`	效率最高。大幅节省令牌，但能力有所下降。	需要最佳速度和最低成本的较简单任务，例如子智能体

并非所有支持 max 的模型都支持 xhigh。

注意

effort 是一种行为信号，而不是严格的令牌预算。在较低的努力程度下，Claude 在面对足够困难的问题时仍会思考，但对于同一问题，思考量会少于较高努力程度时。

以下针对各模型的建议在与此表不同时以建议为准。

effort 与工具使用

使用工具时，effort 参数既影响围绕工具调用的解释，也影响工具调用本身。较低的努力程度往往会：

将多个操作合并为更少的工具调用
进行更少的工具调用
不加铺垫直接采取行动
完成后使用简洁的确认消息

较高的努力程度可能会：

进行更多的工具调用
在采取行动前解释计划
提供详细的更改摘要
包含更全面的代码注释

effort 与思考

thinking 参数控制 Claude 在回答之前是否在思考块中进行思考；effort 参数控制 Claude 在整个响应中投入多少工作量，在自适应模式下，这包括它思考的频率和深度。不要将 adaptive 作为 effort 的值传递：adaptive 是一种思考模式，而不是努力程度级别。

在较高的努力程度下，Claude 会更主动、更长时间地思考。在工具使用循环中，仅处理工具结果的后续请求在任何级别下仍可能跳过思考。在较低的级别下，Claude 对于较简单的问题可能会完全跳过思考。有关这两种控制如何协同工作的完整指导，请参阅思考与努力程度。

在 Claude Opus 4.5（唯一支持 effort 的仅扩展思考模型）上，它与 budget_tokens 配合使用：为您的任务设置努力程度，然后根据任务所需的推理深度设置思考令牌预算。

有关各模型的思考可用性，请参阅各模型配置表。无论是否启用思考，effort 都能发挥作用。请参阅effort 的工作原理。

在对话中途更改 effort

您可以通过两种方式以不同的努力程度运行对话的后续轮次。在 Claude Fable 5.1、Claude Mythos 5.1、Claude Opus 5.5、Claude Opus 5、Claude Sonnet 5.5 和 Claude Haiku 5.5 上，使用按消息更改努力程度的方式，这样可以保留提示缓存。在其他模型上，在下一个请求中设置新的顶层值，这会重新开始缓存。

按消息设置 effort（beta）

按消息设置的努力程度目前处于 beta 阶段。在 Claude API 和 Claude Models on Google Cloud (Google managed) 上，它适用于 Claude Fable 5.1、Claude Mythos 5.1、Claude Opus 5.5、Claude Opus 5、Claude Sonnet 5.5 和 Claude Haiku 5.5。在 Amazon Bedrock 上，它适用于 Claude Fable 5.1、Claude Mythos 5.1 和 Claude Opus 5.5。它需要 beta 标头 mid-conversation-output-config-2026-07-01。使用 Amazon Bedrock InvokeModel API 时，它适用于 Claude Fable 5.1 和 Claude Opus 5.5，并且您需要改为在请求体的 anthropic_beta 数组中发送该值。

如果没有该 beta 值，按消息的 output_config 会返回 400 错误：messages.N.output_config: Extra inputs are not permitted，其中 N 是 system 消息在 messages 中的索引。使用该 beta 值时，不支持按消息设置努力程度的模型（包括 Claude Fable 5）会返回 400 错误：output_config.effort requires a model that supports per-turn effort; this model does not。在 Amazon Bedrock 上，这些模型以及 Claude Opus 5 会改为返回 Extra inputs are not permitted 错误。在使用 thinking: {"type": "between_tools"} 的 Claude Sonnet 5.5 和使用 thinking: {"type": "disabled"} 的 Claude Haiku 5.5 上，努力程度无法在对话中途更改：与当前生效级别不同的按消息 output_config.effort 会返回 400 错误。要为每个轮次改变努力程度，请使用自适应思考。

添加一条 role: "system" 消息，其 content 为空，并在 output_config.effort 中设置新级别。如果将其直接放在包含新输入的 user 轮次之后，它会为 Claude 对该轮次的回复设置级别。如果放在其他任何位置，例如像以下示例那样放在 assistant 轮次和下一个 user 轮次之间，它会从下一个包含新输入的 user 轮次开始生效。仅包含 tool_result 块的 user 轮次不算作新输入，因此在工具使用循环中放在此类轮次之后的更改会等到下一个包含新输入的 user 轮次才生效。之后新级别会一直保持，直到后续消息更改它为止。该消息之前的所有内容都保持不变，因此缓存的前缀仍然匹配。

以下示例从 high 开始，然后针对常规的后续问题降低到 low：

cURL

# 仅含 effort 的系统消息：新级别从下一个用户轮次起生效。
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mid-conversation-output-config-2026-07-01" \
  -H "content-type: application/json" \
  -d '{
    "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."},
      {"role": "system", "content": [], "output_config": {"effort": "low"}},
      {"role": "user", "content": "Summarize the plan in one sentence."}
    ]
  }'

CLI

ant beta:messages create \
  --beta mid-conversation-output-config-2026-07-01 <<'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 的系统消息：新级别从下一个用户轮次起生效。
  - role: system
    content: []
    output_config:
      effort: low
  - role: user
    content: Summarize the plan in one sentence.
YAML

Python

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 的系统消息：新级别从下一个用户轮次起生效。
        {"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)

TypeScript

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 的系统消息：新级别从下一个用户轮次开始生效。
    { 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;
using Model = Anthropic.Models.Messages.Model;

AnthropicClient client = new();

var response = await client.Beta.Messages.Create(new MessageCreateParams
{
    Model = Model.ClaudeFable5_1,
    MaxTokens = 4096,
    OutputConfig = new() { Effort = Effort.High },
    Messages =
    [
        new BetaUserMessageParam { Content = "Plan a migration from SQLite to PostgreSQL in three short steps." },
        new BetaAssistantMessageParam { Content = "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts." },
        // 仅含 effort 的系统消息：新级别从下一个用户轮次起生效。
        new BetaSystemMessageParam
        {
            Content = new([]),
            OutputConfig = new() { Effort = BetaSystemMessageOutputConfigEffort.Low },
        },
        new BetaUserMessageParam { 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:     anthropic.ModelClaudeFable5_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.")),
		{OfAssistant: &anthropic.BetaAssistantMessageParam{
			Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")},
		}},
		// 仅含 effort 的系统消息：新级别从下一个用户轮次起生效。
		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)
	}
}

Java

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

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

    MessageCreateParams params = MessageCreateParams.builder()
        .model(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 的系统消息：新级别从下一个用户轮次起生效。
        .addMessage(BetaSystemMessageParam.builder()
            .contentOfBlocks(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()));
}

PHP

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 的系统消息：新级别从下一个用户轮次开始生效。
        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;
    }
}

Ruby

client = Anthropic::Client.new

response = client.beta.messages.create(
  model: Anthropic::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 的系统消息：新级别从下一个用户轮次起生效。
    {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

仅设置努力程度的系统消息不包含任何文本，因此对话中途系统消息的放置规则不适用。它可以出现在 messages 中的任何位置，包括作为第一个条目，或位于 assistant 轮次和下一个 user 轮次之间。取值为级别名称（low、medium、high、xhigh 和 max）。

与在请求之间更改顶层值相比，应优先使用这种形式。顶层更改会重新开始缓存，并且在 Claude Fable 5.1 上对模型的引导也不太可靠：它之前的回复是在先前级别下编写的，并且它倾向于与这些回复保持一致。

在下一个请求中设置顶层 effort

顶层 output_config.effort 适用于整个请求。要以不同的级别运行对话的后续部分，请在下一个请求中设置新值。由于顶层努力程度会影响渲染后的提示，因此在请求之间更改它不会保留早期轮次的缓存前缀。如果您在长会话中依赖提示缓存，并且您的模型不支持按消息设置努力程度，请在开始时选择一个努力程度并保持不变。

最佳实践

显式设置努力程度：API 默认为 high（Claude Opus 5.5 和 Claude Haiku 5.5 上为 medium），但合适的起点取决于您的模型和工作负载。
对于对速度敏感或简单的任务使用 low：当延迟很重要或任务较为简单时，低努力程度可以显著减少响应时间和成本。
测试您的用例：努力程度的影响因任务类型而异。在部署之前，请评估其在您特定用例上的表现。
考虑动态努力程度：根据任务复杂度调整努力程度。简单查询可能适合低努力程度，而智能体编码和复杂推理则受益于高努力程度。在单个对话中改变努力程度之前，请先参阅下一条。
在缓存的对话中保持顶层努力程度不变：在请求之间更改顶层努力程度值会使提示缓存失效，因此请在不同工作负载之间改变它，而不是在依赖缓存命中的对话中改变。在支持的模型上，请改用按消息更改 effort，这样可以保留缓存。请参阅思考与提示缓存。

后续步骤

任务预算：为 Claude 提供覆盖完整智能体循环的建议性令牌预算，帮助模型在长时间的智能体任务中进行自我调节。
引导思考：了解自适应思考（由 Claude 决定何时思考以及思考多少），并通过努力程度和提示对其进行引导。
思考：了解思考的工作原理、Claude 默认何时思考，以及思考如何与努力程度相互作用。

可用性

Effort在部分模型上可用，并具备零数据保留和HIPAA 就绪资格。

API 支持

Messages API

可用性：始终开启
用法：在请求中设置 output_config.effort。未设置值时，采用模型的默认级别。

状态	云平台	模型
可用	Claude API, Claude Platform on AWS, Amazon Bedrock, Amazon Bedrock (InvokeModel), Claude Models on Google Cloud (Google managed), Microsoft Foundry	Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Mythos Preview, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, Claude Sonnet 5, Claude Haiku 5.5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6, Claude Opus 4.5

Managed Agents

可用性：始终开启
用法：在智能体的模型对象上或会话的模型覆盖中设置 effort。未设置值时，Managed Agents 会填入模型的默认值。

状态	云平台	模型
可用	Claude API, Claude Platform on AWS	Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Mythos Preview, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, Claude Sonnet 5, Claude Haiku 5.5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6, Claude Opus 4.5

数据处理

数据处理概览

项目	零数据保留	HIPAA
状态	具备资格（不包括涵盖的模型）	具备资格

适用的端点：

/v1/messages 使用 effort