---
title: Claude Fable 5.1 提示指南
url: https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1
description: Claude Fable 5.1 和 Claude Mythos 5.1 的行为差异与提示模式，涵盖 effort、进度更新、工具调用批处理、对话历史、写作风格、格式、任务完成、压缩摘要、范围与测试覆盖、搜索触发、安全防护误报、文件编辑、长输出、子代理和视觉。
---
有关该模型的功能、API 变更、定价和可用性，请参阅 [Claude Fable 5.1 的新功能](https://platform.claude.com/docs/zh-CN/models/fable-5-1/whats-new-fable-5-1)。有关适用于各 Claude 模型的通用技术，请参阅[提示最佳实践](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/claude-prompting-best-practices)。
您现有的 Claude Fable 5 提示无需修改即可在 Claude Fable 5.1 上表现良好，但有几处行为差异值得了解。请从与您观察到的情况相符的部分开始阅读：
* 不确定应使用哪个 effort 级别，或延迟和成本高于任务所需：[考虑所有 effort 级别](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#consider-all-effort-levels)
* 工具调用之间很少或没有文本：[要求提供面向用户的进度更新](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#ask-for-user-facing-progress-updates)
* 智能体循环中每轮只有一个工具调用：[在智能体循环中批量发出独立的工具调用](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#batch-independent-tool-calls-in-agent-loops)
* 请求因 `bound to a different conversation` 而失败，或您的 harness 在请求之间编辑了较早的轮次：[保持对话历史仅追加](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-the-conversation-history-append-only)
* 文字冗长且密集：[写作密度](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#writing-density)
* 聊天回复的结构少于内容所需：[聊天中的格式](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#formatting-in-chat)
* 摘要照搬来源措辞却未标注为引用：[引用检索到的来源](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#quoting-retrieved-sources)
* 工作尚未完成轮次就结束，或模型就您已请求的工作征求许可：[完成整个任务](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#finish-the-whole-task)
* 客户端压缩摘要丢失了约束、决策或确切细节：[告诉模型在压缩摘要中保留什么](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#tell-the-model-what-to-preserve-in-compaction-summaries)
* 出现未经请求的修复或扩展，或提交的测试文件多于任务所需：[将更改和测试限制在任务要求的范围内](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-changes-and-tests-to-what-the-task-asks-for)
* 在低 effort 下凭记忆回答而不进行搜索：[低 effort 下的搜索触发](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#search-triggering-at-low-effort)
* 无害的编码请求返回 `stop_reason: "refusal"`：[减少安全防护误报](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#reduce-safeguard-false-positives)
* 为小改动重写整个文件：[优先使用定向编辑而非整文件重写](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#prefer-targeted-edits-over-whole-file-rewrites)
* 在 `xhigh` 或 `max` effort 下，长篇交付物耗时很长或触及 `max_tokens`：[在 xhigh 和 max effort 下为长输出留出空间](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#leave-room-for-long-outputs-at-xhigh-and-max-effort)
* 子代理运行时主代理处于空闲状态：[让主代理在子代理运行时继续工作](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#let-the-lead-agent-keep-working-while-subagents-run)
* 关于图表和密集图像的回答遗漏细节：[为视觉任务提供裁剪和缩放工具](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#give-vision-work-tools-to-crop-and-zoom)
Claude Fable 5.1 运行安全分类器，可能返回 `stop_reason: "refusal"`。请参阅[拒绝、回退和计费](https://platform.claude.com/docs/zh-CN/models/fable-5-1/whats-new-fable-5-1#refusals-fallback-and-billing)和[减少安全防护误报](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#reduce-safeguard-false-positives)。
要求模型写出其思考或推理过程的提示、技能和工具描述可能会以 `reasoning_extraction` 类别被拒绝。请改为要求简短解释或所采取操作的摘要，或从[摘要思考](https://platform.claude.com/docs/zh-CN/build-with-claude/thinking#summarized-thinking)块（`display: "summarized"`）中读取推理。请参阅[将推理保留在思考块中](https://platform.claude.com/docs/zh-CN/build-with-claude/refusals-and-fallback#keep-reasoning-in-thinking-blocks)。
## 考虑所有 effort 级别
从默认的 [effort](https://platform.claude.com/docs/zh-CN/build-with-claude/effort)（努力程度）级别 `high` 开始，然后用您自己的评估测试其他级别（`low`、`medium`、`xhigh` 和 `max`）。在 Claude Fable 5.1 上，effort 是在智能、延迟和成本之间进行权衡的主要控制手段。即使您已经在 Claude Fable 5 上做过一轮对比测试，也请重新进行：相同名称的 effort 级别在不同模型上对应的思考量并不相同。
Claude Fable 5.1 相对于 Claude Fable 5 的能力提升体现在各个 effort 级别上，并且在较高设置下最为明显。在 `medium` 下，结果与 Claude Fable 5 大致相当，但成本更低，因此在评估显示质量能够保持的场景中，可以降到 `medium` 或 `low`。在 `low` 下，Claude Fable 5.1 的单任务成本通常可与 Claude Opus 和 Claude Sonnet 模型相竞争，同时得分更高，因此在您原本会以较高 effort 级别运行较小模型的场景中，请将其纳入比较。
有两种与 effort 相关的行为各有专门章节：在 `low` 下，Claude Fable 5.1 调用搜索和检索工具的频率较低（请参阅[低 effort 下的搜索触发](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#search-triggering-at-low-effort)）；在 `xhigh` 和 `max` 下，它在撰写长篇交付物之前可能会思考更长时间（请参阅[在 xhigh 和 max effort 下为长输出留出空间](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#leave-room-for-long-outputs-at-xhigh-and-max-effort)）。
## 要求提供面向用户的进度更新
在较长的工具调用轮次中，Claude Fable 5.1 默认撰写的面向用户的更新比 Claude Fable 5 少。在较高 effort 和较长的工具链中，这一点更加明显。用户会看到智能体一连几分钟没有动静，或者最终消息只涵盖最后一步，而不是整个任务。
首先，检查您的客户端是否确实收到了进度更新。模型在工具调用之间写下的简短说明（刚刚发现了什么、接下来要做什么）会以[进度更新 `thinking` 块](https://platform.claude.com/docs/zh-CN/build-with-claude/thinking#progress-updates)的形式返回，而在默认的 `thinking.display` 值 `"omitted"` 下，这些块是空的。请设置 `display: "updates"`（beta，需 `thinking-display-updates-2026-08-18` 标头），并将每个非空的 `thinking` 块渲染为一条状态行；或者设置 `"summarized"`，以便连同摘要化的推理一起接收它们。如果您没有请求这些内容，模型的更新可能根本没有传达给您的用户。
其次，检查您的提示中是否有抑制叙述的指令。一些早期模型在工作时热衷于提供更新，因此产生了诸如"将所有发现留到最终回复中"之类的系统提示语句。在添加任何内容之前，请先删除此类语句。
如果您仍然希望获得更多更新，例如在结对编程或其他人机协同工作中，请添加一行简短的系统提示，说明您希望模型在何时输出面向用户的文本，以及每条更新应包含什么内容：
```text wrap
Before you start, say in a line what you're about to do; brief updates while you work help the user follow along. Close with a short recap that stands on its own — what you found, what you did, and what's next — so a reader who only sees the last message has the full picture.
```
如果您的产品会折叠或隐藏工具输出，请告知模型。否则，它可能会运行命令来向用户"展示"您的 UI 从不显示的输出。请通过[轮次作用域系统消息](https://platform.claude.com/docs/zh-CN/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages)（`clear_at: "next_user_message"`，beta）传达这条说明：
```text wrap
Only you see that command's output — the user's terminal shows at most a few lines of it. If the user needs to read any of it, put it in your reply.
```
## 在智能体循环中批量发出独立的工具调用
Claude Fable 5.1 通常会按预期发出并行工具调用：当请求列出了多个需要获取的内容时，它会并行发出这些调用。例外情况是编码和计算机使用循环，其中接下来的独立调用是由任务隐含的，而非明确请求的（自定义编码智能体、bash 加编辑器的 harness（运行框架）、计算机使用）：在这些场景中，它可能改为每轮只发出一个调用。这不会影响回答质量，但每多一轮都会消耗令牌、一次往返和实际耗时。在当前请求末尾加一句提示即可解决：
```text wrap
First privately list what you need next; then request every item that doesn't depend on another's result in this one response.
```
每次发回工具结果时，将这句话作为[轮次作用域系统消息](https://platform.claude.com/docs/zh-CN/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages)追加在该用户消息之后：即 `messages` 中一个带有 `clear_at: "next_user_message"` 的 `role: "system"` 条目。一旦出现后续用户消息，API 就会清除较早的副本，因此模型只会读到最新的那一份。轮次作用域系统消息目前处于 beta 阶段，需要使用 [beta 标头](https://platform.claude.com/docs/zh-CN/api/beta-headers) `mid-conversation-system-clear-at-2026-08-21`。如果不使用该 beta，请改为将这句话放在同一用户消息中 `tool_result` 块之后的文本块里。
每轮追加一份新副本，并让较早的副本逐字节保持原样。它们仍留在数组中，但一旦被清除，模型就看不到它们，也不会消耗输入令牌。删除或改写它们属于对较早轮次的编辑：这会使[提示缓存](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-caching)从该位置重新开始，并使其后的 thinking 块失效（请参阅[保持对话历史仅追加](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-the-conversation-history-append-only)）。
以下循环展示了这种放置方式。每个助手轮次都按返回时的原样发回，每个用户轮次只携带工具结果，其后紧跟一份新的轮次作用域提示副本。
```python Python
import anthropic
from anthropic.types.beta import (
BetaMessageParam,
BetaToolParam,
BetaToolResultBlockParam,
)
client = anthropic.Anthropic()
BATCH_NUDGE = (
"First privately list what you need next; then request every item "
"that doesn't depend on another's result in this one response."
)
# 内存中的文件充当工作目录，使示例可在任何地方运行。
FILES = {
"pyproject.toml": """\
[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
""",
"README.md": """\
# demo
A small demo project. Run `demo --help` for usage.
""",
}
tools: list[BetaToolParam] = [
{
"name": "read_file",
"description": "Read a UTF-8 text file from the working directory.",
"input_schema": {
"type": "object",
"properties": {"path": {"type": "string"}},
"required": ["path"],
},
}
]
messages: list[BetaMessageParam] = [
{"role": "user", "content": "Summarize pyproject.toml and README.md."}
]
while True:
response = client.beta.messages.create(
model="claude-fable-5-1",
max_tokens=16000,
betas=["mid-conversation-system-clear-at-2026-08-21"],
tools=tools,
messages=messages,
)
# 按返回的原样追加 assistant 轮次，包括思考块。
messages.append({"role": "assistant", "content": response.content})
if response.stop_reason != "tool_use":
break
tool_results: list[BetaToolResultBlockParam] = []
for block in response.content:
if block.type == "tool_use":
raw_path = block.input.get("path")
path = raw_path if isinstance(raw_path, str) else ""
if path in FILES:
tool_results.append(
{
"type": "tool_result",
"tool_use_id": block.id,
"content": FILES[path],
}
)
else:
tool_results.append(
{
"type": "tool_result",
"tool_use_id": block.id,
"content": f"File not found: {path}",
"is_error": True,
}
)
# 将工具结果作为 user 轮次发送，然后将提示的新副本作为
# 轮次范围的系统消息发送。保留先前的副本：API 会清除它们，
# 因此模型只会看到最新的一个。
messages.append({"role": "user", "content": tool_results})
messages.append(
{"role": "system", "content": BATCH_NUDGE, "clear_at": "next_user_message"}
)
print(next((block.text for block in response.content if block.type == "text"), ""))
```
```typescript TypeScript
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();
const BATCH_NUDGE =
"First privately list what you need next; then request every item " +
"that doesn't depend on another's result in this one response.";
// 内存中的文件充当工作目录，使示例可在任何地方运行。
const FILES = new Map([
[
"pyproject.toml",
`[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
`,
],
[
"README.md",
`# demo
A small demo project. Run \`demo --help\` for usage.
`,
],
]);
const tools: Anthropic.Beta.Messages.BetaTool[] = [
{
name: "read_file",
description: "Read a UTF-8 text file from the working directory.",
input_schema: {
type: "object",
properties: { path: { type: "string" } },
required: ["path"],
},
},
];
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Summarize pyproject.toml and README.md." },
];
let response: Anthropic.Beta.Messages.BetaMessage;
while (true) {
response = await client.beta.messages.create({
model: "claude-fable-5-1",
max_tokens: 16000,
betas: ["mid-conversation-system-clear-at-2026-08-21"],
tools,
messages,
});
// 按返回的原样追加 assistant 轮次，包括思考块。
messages.push({ role: "assistant", content: response.content });
if (response.stop_reason !== "tool_use") {
break;
}
const toolResults: Anthropic.Beta.Messages.BetaToolResultBlockParam[] = [];
for (const block of response.content) {
if (block.type !== "tool_use") {
continue;
}
const { input } = block;
const path =
typeof input === "object" &&
input !== null &&
"path" in input &&
typeof input.path === "string"
? input.path
: "";
const text = FILES.get(path);
if (text === undefined) {
toolResults.push({
type: "tool_result",
tool_use_id: block.id,
content: `File not found: ${path}`,
is_error: true,
});
continue;
}
toolResults.push({
type: "tool_result",
tool_use_id: block.id,
content: text,
});
}
// 将工具结果作为 user 轮次发送，然后将提示的新副本作为
// 轮次范围的系统消息发送。保留先前的副本：API 会清除它们，
// 因此模型只会看到最新的一个。
messages.push({ role: "user", content: toolResults });
messages.push({
role: "system",
content: BATCH_NUDGE,
clear_at: "next_user_message",
});
}
const finalText = response.content.find((block) => block.type === "text");
console.log(finalText?.text ?? "");
```
```csharp C#
using System.Text.Json;
using Anthropic;
using Anthropic.Models.Beta.Messages;
using Model = Anthropic.Models.Messages.Model;
AnthropicClient client = new();
const string BatchNudge =
"First privately list what you need next; then request every item "
+ "that doesn't depend on another's result in this one response.";
// 内存中的文件充当工作目录，使示例可在任何地方运行。
Dictionary files = new()
{
["pyproject.toml"] = """
[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
""",
["README.md"] = """
# demo
A small demo project. Run `demo --help` for usage.
""",
};
List tools =
[
new BetaTool
{
Name = "read_file",
Description = "Read a UTF-8 text file from the working directory.",
InputSchema = new InputSchema
{
Properties = new Dictionary
{
["path"] = JsonSerializer.SerializeToElement(new { type = "string" }),
},
Required = ["path"],
},
},
];
List messages =
[
new() { Role = Role.User, Content = "Summarize pyproject.toml and README.md." },
];
BetaMessage response;
while (true)
{
response = await client.Beta.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeFable5_1,
MaxTokens = 16000,
Betas = ["mid-conversation-system-clear-at-2026-08-21"],
Tools = tools,
Messages = messages,
});
// 按返回的原样追加 assistant 轮次，包括思考块。
messages.Add(new()
{
Role = Role.Assistant,
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
});
if (response.StopReason != BetaStopReason.ToolUse)
{
break;
}
List toolResults = [];
foreach (var block in response.Content)
{
if (block.TryPickToolUse(out var toolUse))
{
var path = toolUse.Input.TryGetValue("path", out var pathValue)
&& pathValue.ValueKind == JsonValueKind.String
? pathValue.GetString()!
: "";
if (files.TryGetValue(path, out var fileText))
{
toolResults.Add(new BetaToolResultBlockParam { ToolUseID = toolUse.ID, Content = fileText });
}
else
{
toolResults.Add(new BetaToolResultBlockParam
{
ToolUseID = toolUse.ID,
Content = $"File not found: {path}",
IsError = true,
});
}
}
}
// 将工具结果作为 user 轮次发送，然后将提示的新副本作为
// 轮次范围的系统消息发送。保留先前的副本：API 会清除它们，
// 因此模型只会看到最新的一个。
messages.Add(new() { Role = Role.User, Content = toolResults });
messages.Add(new()
{
Role = Role.System,
Content = BatchNudge,
ClearAt = ClearAt.NextUserMessage,
});
}
foreach (var block in response.Content)
{
if (block.TryPickText(out var text))
{
Console.WriteLine(text.Text);
break;
}
}
```
```go Go
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"github.com/anthropics/anthropic-sdk-go"
)
const batchNudge = "First privately list what you need next; then request every item " +
"that doesn't depend on another's result in this one response."
// 内存中的文件充当工作目录，使示例可在任何地方运行。
var files = map[string]string{
"pyproject.toml": `[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
`,
"README.md": `# demo
A small demo project. Run "demo --help" for usage.
`,
}
func main() {
client := anthropic.NewClient()
ctx := context.Background()
tools := []anthropic.BetaToolUnionParam{
{OfTool: &anthropic.BetaToolParam{
Name: "read_file",
Description: anthropic.String("Read a UTF-8 text file from the working directory."),
InputSchema: anthropic.BetaToolInputSchemaParam{
Properties: map[string]any{
"path": map[string]any{"type": "string"},
},
Required: []string{"path"},
},
}},
}
messages := []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Summarize pyproject.toml and README.md.")),
}
var response *anthropic.BetaMessage
for {
var err error
response, err = client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeFable5_1,
MaxTokens: 16000,
Betas: []anthropic.AnthropicBeta{"mid-conversation-system-clear-at-2026-08-21"},
Tools: tools,
Messages: messages,
})
if err != nil {
log.Fatal(err)
}
// 按返回的原样追加 assistant 轮次，包括思考块。
messages = append(messages, response.ToParam())
if response.StopReason != anthropic.BetaStopReasonToolUse {
break
}
var toolResults []anthropic.BetaContentBlockParamUnion
for _, block := range response.Content {
toolUse, ok := block.AsAny().(anthropic.BetaToolUseBlock)
if !ok {
continue
}
var input struct {
Path string `json:"path"`
}
// path 缺失或不是字符串时，input.Path 为空，从而进入错误结果分支。
if err := json.Unmarshal([]byte(toolUse.JSON.Input.Raw()), &input); err != nil {
input.Path = ""
}
text, found := files[input.Path]
if !found {
text = "File not found: " + input.Path
}
toolResults = append(toolResults, anthropic.NewBetaToolResultBlock(toolUse.ID, text, !found))
}
// 将工具结果作为 user 轮次发送，然后将提示的新副本作为
// 轮次范围的系统消息发送。保留先前的副本：API 会清除它们，
// 因此模型只会看到最新的一个。
messages = append(messages, anthropic.NewBetaUserMessage(toolResults...))
messages = append(messages, anthropic.BetaMessageParam{
Role: anthropic.BetaMessageParamRoleSystem,
Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock(batchNudge)},
ClearAt: anthropic.BetaMessageParamClearAtNextUserMessage,
})
}
for _, block := range response.Content {
if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
fmt.Println(textBlock.Text)
break
}
}
}
```
```java Java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.JsonValue;
import com.anthropic.models.beta.messages.BetaContentBlockParam;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaMessageParam;
import com.anthropic.models.beta.messages.BetaStopReason;
import com.anthropic.models.beta.messages.BetaTool;
import com.anthropic.models.beta.messages.BetaTool.InputSchema;
import com.anthropic.models.beta.messages.BetaToolResultBlockParam;
import com.anthropic.models.beta.messages.BetaToolUseBlock;
import com.anthropic.models.beta.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
static final String BATCH_NUDGE =
"First privately list what you need next; then request every item "
+ "that doesn't depend on another's result in this one response.";
// 内存中的文件充当工作目录，使示例可在任何地方运行。
static final Map FILES = Map.of(
"pyproject.toml", """
[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
""",
"README.md", """
# demo
A small demo project. Run `demo --help` for usage.
""");
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
BetaTool readFileTool = BetaTool.builder()
.name("read_file")
.description("Read a UTF-8 text file from the working directory.")
.inputSchema(InputSchema.builder()
.properties(JsonValue.from(Map.of("path", Map.of("type", "string"))))
.required(List.of("path"))
.build())
.build();
List messages = new ArrayList<>();
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.USER)
.content("Summarize pyproject.toml and README.md.")
.build());
BetaMessage response;
while (true) {
response = client.beta().messages().create(MessageCreateParams.builder()
.model(Model.CLAUDE_FABLE_5_1)
.maxTokens(16000)
.addBeta("mid-conversation-system-clear-at-2026-08-21")
.addTool(readFileTool)
.messages(messages)
.build());
// 按返回的原样追加 assistant 轮次，包括思考块。
messages.add(response.toParam());
boolean requestedTools = response.stopReason()
.map(BetaStopReason.TOOL_USE::equals)
.orElse(false);
if (!requestedTools) {
break;
}
List toolUses = response.content().stream()
.flatMap(block -> block.toolUse().stream())
.toList();
List toolResults = new ArrayList<>();
for (BetaToolUseBlock toolUse : toolUses) {
Map input =
(Map) toolUse._input().asObject().orElseThrow();
JsonValue pathValue = input.get("path");
String path = pathValue != null && pathValue.asString().isPresent()
? pathValue.asStringOrThrow()
: "";
String fileText = FILES.get(path);
BetaToolResultBlockParam.Builder result = BetaToolResultBlockParam.builder()
.toolUseId(toolUse.id());
if (fileText != null) {
result.content(fileText);
} else {
result.content("File not found: " + path).isError(true);
}
toolResults.add(BetaContentBlockParam.ofToolResult(result.build()));
}
// 将工具结果作为 user 轮次发送，然后将提示的新副本作为
// 轮次范围的系统消息发送。保留先前的副本：API 会清除它们，
// 因此模型只会看到最新的一个。
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.USER)
.contentOfBetaContentBlockParams(toolResults)
.build());
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.SYSTEM)
.content(BATCH_NUDGE)
.clearAt(BetaMessageParam.ClearAt.NEXT_USER_MESSAGE)
.build());
}
String finalText = response.content().stream()
.flatMap(block -> block.text().stream())
.map(textBlock -> textBlock.text())
.findFirst()
.orElse("");
IO.println(finalText);
}
```
```php PHP
<<<'TOML'
[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
TOML,
'README.md' => <<<'MD'
# demo
A small demo project. Run `demo --help` for usage.
MD,
];
$tools = [
[
'name' => 'read_file',
'description' => 'Read a UTF-8 text file from the working directory.',
'input_schema' => [
'type' => 'object',
'properties' => ['path' => ['type' => 'string']],
'required' => ['path'],
],
],
];
$messages = [
['role' => 'user', 'content' => 'Summarize pyproject.toml and README.md.'],
];
while (true) {
$response = $client->beta->messages->create(
model: 'claude-fable-5-1',
maxTokens: 16000,
betas: ['mid-conversation-system-clear-at-2026-08-21'],
tools: $tools,
messages: $messages,
);
// 按返回的原样追加 assistant 轮次，包括思考块。
$messages[] = ['role' => 'assistant', 'content' => $response->content];
if ($response->stopReason !== BetaStopReason::TOOL_USE->value) {
break;
}
$toolResults = [];
foreach ($response->content as $block) {
if ($block->type === 'tool_use') {
$path = is_string($block->input['path'] ?? null) ? $block->input['path'] : '';
if (array_key_exists($path, FILES)) {
$toolResults[] = [
'type' => 'tool_result',
'tool_use_id' => $block->id,
'content' => FILES[$path],
];
} else {
$toolResults[] = [
'type' => 'tool_result',
'tool_use_id' => $block->id,
'content' => "File not found: {$path}",
'is_error' => true,
];
}
}
}
// 将工具结果作为 user 轮次发送，然后将提示的新副本作为
// 轮次范围的系统消息发送。保留先前的副本：API 会清除它们，
// 因此模型只会看到最新的一个。
$messages[] = ['role' => 'user', 'content' => $toolResults];
$messages[] = [
'role' => 'system',
'content' => BATCH_NUDGE,
'clear_at' => 'next_user_message',
];
}
$textBlock = array_find($response->content, fn ($block) => $block->type === 'text');
echo $textBlock?->text ?? '', PHP_EOL;
```
```ruby Ruby
require "anthropic"
client = Anthropic::Client.new
BATCH_NUDGE =
"First privately list what you need next; then request every item " \
"that doesn't depend on another's result in this one response."
# 内存中的文件充当工作目录，使示例可在任何地方运行。
FILES = {
"pyproject.toml" => <<~TOML,
[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
TOML
"README.md" => <<~MD
# demo
A small demo project. Run `demo --help` for usage.
MD
}
tools = [
{
name: "read_file",
description: "Read a UTF-8 text file from the working directory.",
input_schema: {
type: "object",
properties: {path: {type: "string"}},
required: ["path"]
}
}
]
messages = [{role: "user", content: "Summarize pyproject.toml and README.md."}]
response = nil
loop do
response = client.beta.messages.create(
model: "claude-fable-5-1",
max_tokens: 16000,
betas: ["mid-conversation-system-clear-at-2026-08-21"],
tools: tools,
messages: messages
)
# 按返回的原样追加 assistant 轮次，包括思考块。
messages << {role: "assistant", content: response.content}
break unless response.stop_reason == :tool_use
tool_results = response.content.filter_map do |block|
next unless block.type == :tool_use
path = block.input[:path]
if FILES.key?(path)
{type: "tool_result", tool_use_id: block.id, content: FILES[path]}
else
{
type: "tool_result",
tool_use_id: block.id,
content: "File not found: #{path}",
is_error: true
}
end
end
# 将工具结果作为 user 轮次发送，然后将提示的新副本作为
# 轮次范围的系统消息发送。保留先前的副本：API 会清除它们，
# 因此模型只会看到最新的一个。
messages << {role: "user", content: tool_results}
messages << {role: "system", content: BATCH_NUDGE, clear_at: "next_user_message"}
end
puts response.content.find { it.type == :text }&.text
```
## 保持对话历史仅追加
将每个助手轮次按 API 返回时的原样（包括 thinking 块）追加到历史中，并且不要在请求之间编辑较早的轮次。对于 2026 年 8 月 31 日或之后创建的新账户，Claude Fable 5.1 的 thinking 块[仅在生成它们的那个确切对话中有效](https://platform.claude.com/docs/zh-CN/build-with-claude/thinking#preserved-in-conversation)：如果请求在 thinking 块的前缀（系统提示、工具列表或任何较早的消息）发生变化后重放该块，将返回 400 错误；如果您设置了 `thinking.block_binding.prefix_mismatch_behavior: "drop_block"`（beta，需要 `thinking-binding-controls-2026-08-01` 标头），则会丢弃受影响的块。即使您的账户未强制执行此检查，也请采用这种模式，以便同一套代码在所有账户上都能正常工作。
会触发该检查的历史编辑，与会使[提示缓存](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-caching)重新开始的编辑相同：注入和移除每轮提醒、就地摘要较早的轮次，或在会话中途更改系统提示。请将每轮提醒作为[轮次作用域系统消息](https://platform.claude.com/docs/zh-CN/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages)发送；使用[对话中系统消息](https://platform.claude.com/docs/zh-CN/build-with-claude/mid-conversation-system-messages)来更改指令或工具，而不是改写 `system` 或 `tools`；并让服务器端的 [compaction](https://platform.claude.com/docs/zh-CN/build-with-claude/compaction)（压缩）或 [context editing](https://platform.claude.com/docs/zh-CN/build-with-claude/context-editing)（上下文编辑）来完成任何裁剪。如果您在客户端进行压缩，最简单的做法是用一条摘要消息加上新的用户轮次替换整个历史，不重放任何其他内容：这样不会有 thinking 块被带过去，因此不会出现失败，模型也会针对压缩后的对话重新思考（请参阅[客户端自定义压缩](https://platform.claude.com/docs/zh-CN/build-with-claude/preserved-thinking#custom-compaction-on-the-client)）。由于缓存读取现在更便宜（请参阅[定价](https://platform.claude.com/docs/zh-CN/models/fable-5-1/whats-new-fable-5-1#pricing)），在 Claude Fable 5.1 上为节省成本而提前压缩可能不再是成本与智能之间的最佳权衡，因此请尝试更晚的压缩时机。
要找出您的 harness 已经在进行的编辑，可以按照[如何判断您的集成是否受影响](https://platform.claude.com/docs/zh-CN/build-with-claude/preserved-thinking#how-to-tell-whether-your-integration-is-impacted)中的说明，使用 `prefix_mismatch_behavior: "drop_block"` 运行一个会话并记录 `input_transformations`；或者捕获它在几个正常轮次中发送的确切请求，并确认连续请求之间除追加的轮次外逐字节相同。
## 写作密度
Claude Fable 5.1 的写作很少使用套话，也很少出现未加解释的术语。不过在某些情况下，它的文字比 Claude Fable 5 更密集：句子更长，分段更少。定义这种反模式（即矫揉造作的文字）的指令会有所帮助。请将其添加到用户消息（首选）或系统提示中：
```text wrap
Mannered prose substitutes metaphor and flourish for direct statement. Instead of "a parameter worth varying," the mannered writer produces "a dial worth turning." Instead of "this point still matters," they write "this point earns its keep." The phrases exist to display the writer, not to convey the idea, and readers can tell. That is why mannered prose irritates: it makes the reader work harder so the writer can perform. It is also imprecise. Metaphors drag in connotations the writer did not choose and cannot control. The fix is to say what you mean. When a literal phrase is available, use it.
```
简短版本通常也有效：
```text wrap
Please remove all mannered prose.
```
## 聊天中的格式
早期模型在聊天中过度使用项目符号和粗体，许多提示中都带有为抑制这一点而编写的反格式规则。Claude Fable 5.1 则倾向于另一个方向：它较少使用粗体，也不太会使用标题、列表或引号。如果您的提示中包含反格式的措辞，请将其删除，或替换为一条说明何时适合使用特定格式的规则，例如：
```text wrap
Use lists and bullet points when asked to, or when the content is multifaceted enough that they help with clarity. If the person explicitly requests minimal formatting, always format your responses without bullet points, headers, lists, or bold emphasis, as requested. In conversational, personal, or emotional exchanges, keep to plain prose.
```
## 引用检索到的来源
在摘要文档时，Claude Fable 5.1 比 Claude Fable 5 更有可能照搬源文本的段落而不将其标注为引用。要解决这个问题，请在系统提示中添加一个完整的正确回复示例：包括用户的请求、回复，以及一句解释该回复为何正确的说明。
```text wrap
look up how the Riverton Ledger and the Coast Dispatch each covered the Harbor Bridge closure and compare their reporting
[web_search: Harbor Bridge closure Riverton Ledger]
[web_search: Harbor Bridge closure Coast Dispatch]
Both outlets agree on the basics: the bridge closed on March 3 after inspectors found cracked welds, and the state expects repairs to take about eight months. Where they differ is emphasis. The Ledger treats it as a local-economy story. The Dispatch frames it as a funding failure; its editorial calls the closure "entirely foreseeable." Read together, the Ledger explains who is affected now and the Dispatch explains how it came to this — neither account alone gives the whole picture.
CORRECT: The response is organized around where the two outlets agree and differ, not as a walk through either article. Each outlet's reporting is conveyed in one or two sentences of the assistant's own indirect speech. One short marked phrase from one source; every other claim is reworded. The response is still specific and complete.
```
请将两行 `[web_search: ...]` 替换为您自己工具的名称，以便模型将其理解为模板化的工具输出，而不是需要原样输出的文本。
## 完成整个任务
Claude Fable 5.1 可以在没有太多方法论指导的情况下执行非常长的任务，尤其是在目标明确时。不过，在复杂的异步工作负载中，请提示它不要在工作完成之前结束轮次。如果没有这一提示，模型有时会描述接下来要做什么而不是实际去做（"接下来，我将……"），或者停下来为原始请求已经涵盖的步骤征求许可（"要我应用这个更改吗？"）。用户不得不回复"继续"或"开始吧"，这适合结对编程和其他人机协同工作，但没有充分发挥模型的长周期能力。
两条系统提示补充内容结合使用可以缓解这一问题。请同时应用两者。如果您需要限制提示长度，只使用第一条即可，它能保留大部分效果。第一条告诉模型不要就已请求的工作提问，并执行它已声明的后续步骤：
```text wrap
You are operating autonomously. The user is not watching in real time and cannot answer questions mid-task, so asking 'Want me to…?' or 'Shall I…?' will block the work. For reversible actions that follow from the original request, proceed without asking. Stop only for destructive actions or genuine scope changes the user must decide. Offering follow-ups after the task is done is fine; asking permission before doing the work is not.
Exception: when the user is describing a problem, asking a question, or thinking out loud rather than requesting a change, the deliverable is your assessment. Report your findings and stop. Don't apply a fix until they ask for one.
Before ending your turn, check your last paragraph. If it is a plan, an analysis, a question, a list of next steps, or a promise about work you have not done ('I'll…', 'let me know when…'), do that work now with tool calls. That includes retrying after errors and gathering missing information yourself. Do not stop because the context or session is long. End your turn only when the task is complete or you are blocked on input only the user can provide.
Before running a command that changes system state (such as restarts, deletes, or config edits), check that the evidence actually supports that specific action. A signal that pattern-matches to a known failure may have a different cause.
```
开头那句告诉模型用户并未在旁观看的话，承担了大部分效果。请保持原样。如果您的产品需要模型在特定确认点停下，请在其后添加一句话列出这些确认点。这段内容也可能使模型不太会就含糊的请求提问，因此请在您自己的任务上检验这一权衡。
第二条将用户的请求定义为交付物的范围：
```text wrap
# Delivering work
The user's request — or the plan they approved — sets the scope, and the scope is the deliverable: don't quietly narrow, widen, or swap it. Read ambiguity the way a careful colleague would: make routine judgment calls yourself, and check in only when different readings would lead to materially different work. If you see a real problem with the task as specified, say so in a sentence or two and keep building under stated assumptions; if the user hears the concern and reaffirms, that is their decision, so deliver the full request.
If a question comes up partway, first do everything that doesn't depend on the answer; then state the assumption you made, or — when going ahead on a wrong guess would be unsafe or would make the work useless — put the question at the end of a turn that also delivers that progress. If one part turns out to be blocked, complete every other part in full and say exactly what you left out and why — the whole task is the deliverable, and scaling it down is the user's call, not yours. A step you have decided on is something to run, not to announce: describing the next step and ending the turn leaves it undone until the user replies.
Keep changes to what the request needs. Something else you notice worth doing — cleanup or documentation the task didn't call for, a change to a file the task didn't require — is a suggestion to make at the end, not a change to make; actions clearly beyond what the ask implies, and risky or destructive ones, still need the user's go-ahead.
```
## 告诉模型在压缩摘要中保留什么
当长对话被压缩时，明确告诉 Claude Fable 5.1 其摘要必须保留哪些内容，效果会很好。服务器端的 [compaction](https://platform.claude.com/docs/zh-CN/build-with-claude/compaction)（压缩）已经这样做了。如果您在客户端进行压缩，请使用以下摘要指令：
```text wrap
Summarize the transcript inside tags. Include relevant information in the summary such that this conversation will be continued by a new context window without needing to redo work or be reprovided with relevant constraints or context. Be sure to preserve: (1) any difficulties or problems that came up, and how they were handled or resolved; (2) any possibilities, options, or approaches that were raised, tried, or set aside, and why; (3) anything that was asked for, decided, agreed, ruled out, or established as a preference, constraint, or boundary — stated exactly; (4) exactly where things stand now — what has been covered, settled, or completed so far; (5) anything still open, unresolved, promised, or expected to happen next; (6) specific details that would be hard to reconstruct — names, numbers, dates, exact wording, links or references — kept exactly. Be complete on these even at the cost of length; keep everything else concise. Weight the two voices differently: keep what the user said, asked for, shared, or established carefully and close to their own words; your own explanations and reasoning can be condensed much further, to what they concluded or produced — as long as nothing in the six items above is dropped.
```
## 将更改和测试限制在任务要求的范围内
当被要求实现一个开放式功能时，Claude Fable 5.1 会交付所要求的内容，有时还会更多：它可能会修复附近的代码、扩展任务未提及的行为，或提交超出更改所需的测试文件。它对明确说明哪些内容不要做的指令响应良好。使用以下指令后，未经请求的添加和提交的测试代码会大幅减少，而任务成功率没有可测量的变化：
```text wrap
If, while working or testing, you find a pre-existing bug, a performance concern, or behavior the task doesn't mention, don't fix, optimize or extend it in this change unless the requested behavior cannot work without it; report it as a follow-up in your summary. Where the task is ambiguous, implement the reading its wording and the surrounding code most directly support, state that assumption in your summary, and don't build for the other readings as well. Verify your work however you like; scratch scripts and quick checks need not be kept. Commit tests only where the task asks for them or this repository already keeps tests for this kind of change, sized like the neighboring test files — roughly one focused test per stated behavior — and don't turn scratch checks into additional permanent test files. This is about extras only: implement every behavior the task asks for, completely.
```
## 低 effort 下的搜索触发
在 `low` effort 下，Claude Fable 5.1 比 Claude Fable 5 更不容易调用搜索或检索工具，而更可能凭记忆回答。在某些情况下，最简单的解决方法是只为受影响的轮次提高 effort，而不是整个对话。请参阅[在对话中途更改 effort](https://platform.claude.com/docs/zh-CN/build-with-claude/effort#changing-effort-mid-conversation)。
在其他情况下，引导模型进行核实的提示会有所帮助。在系统提示中说明：认出一个名称并不等于了解其当前状态，并且应按用户所写的原样搜索此类名称：
```text wrap
When a query centers on a name you do not confidently recognize, or recognize from a fast-moving area like AI models and developer tools where the landscape shifts within months, the name itself is the thing to verify: search before answering, and include the name as the user wrote it in at least one query alongside any reformulations. This holds even when you have some background on it — partial background is exactly what makes an out-of-date answer sound authoritative, so familiarity is not a reason to skip the search.
```
## 减少安全防护误报
Claude Fable 5.1 的安全分类器产生的 false positives（误报）比 Claude Fable 5 发布时更少，并且允许在源代码中查找漏洞。误报仍会发生，被拦截的请求会返回 `stop_reason: "refusal"`（请参阅[拒绝、回退和计费](https://platform.claude.com/docs/zh-CN/models/fable-5-1/whats-new-fable-5-1#refusals-fallback-and-billing)）。以下三种情况更容易引发误报：
* **编译检查式措辞：** 不要问"这个程序能否无错误地编译？"，而应问"这个程序中有没有 bug？"
* **较冷门的编程语言：** 向模型提供有关该语言是什么以及如何工作的上下文，例如让它能够访问该语言的文档。
* **工具输出中的 Base64：** 向模型上下文返回 base64 编码数据的工具可能会触发误报，因此建议的解决方法是移除这些工具。
## 优先使用定向编辑而非整文件重写
如果 Claude Fable 5.1 为小改动重写整个文件，请将以下指令追加到系统提示或第一条用户消息中。与 Claude Fable 5 相比，Claude Fable 5.1 更有可能重写整个文本文件，而不是进行定向编辑。生成的文件通常是相同的，但除非文件很短或大部分内容都在更改，否则重写会消耗更多输出令牌和时间。这条指令能让 Claude Fable 5.1 在小型和中型更改上恢复到与 Claude Fable 5 一致的行为。
```text wrap
The number of tokens used to edit files is best minimized, all else being equal. Therefore, when it will not affect the end result, try to surgically edit a file rather than rewrite the entire thing.
```
## 在 xhigh 和 max effort 下为长输出留出空间
在 `xhigh`，尤其是 `max` effort 下，Claude Fable 5.1 在开始撰写回复之前可能会思考更长时间。当单个请求要求一份长篇交付物（例如完整重写一份长文档）时，它可能会在思考中起草该交付物的大部分内容，然后在回复中再写一遍，这意味着更长的等待时间和更多的输出令牌。最简单的做法是以推荐的起点 `high` 运行此类请求，只有在您已测得质量提升的情况下才改用 `xhigh` 或 `max`（请参阅[考虑所有 effort 级别](https://platform.claude.com/docs/zh-CN/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#consider-all-effort-levels)）。如果您确实以 `xhigh` 或 `max` 运行它们：
* 设置 `max_tokens` 时，要为思考和回复都留出空间，而不仅仅是您预期的回复长度。
* 将以下说明追加到用户消息的末尾。它能使散文和代码请求的思考大幅缩短。请将 `[max_tokens]` 替换为该请求实际的 `max_tokens` 值，例如 64,000。
```text wrap
Everything produced in one reply, including any reasoning or drafting done before the reply, counts toward a single limit of about [max_tokens] tokens. If that limit is reached before the reply is finished, the person receives a cut-off response and has to start over. Composing an entire output or deliverable in full as reasoning and then again as a reply would double the length of the turn without improving the result, so don't do that.
Instead, when the person has asked for a long or effort-intensive deliverable such as a multi-section document, a large table or dataset, or a complete code file, spend extra effort on understanding the request, checking the inputs the answer depends on, settling the structure and other difficult decisions, and otherwise using the reasoning space to reason and the output space to write an output. Usually it is not needed to draft an output multiple times.
```
## 让主代理在子代理运行时继续工作
如果您的编码智能体允许 Claude Fable 5.1 将工作委派给 subagents（子代理），请不要强制主代理停下来等待每个子代理。在编码任务中，让主代理在子代理运行时继续工作，可以在质量、令牌用量和成本相近的情况下缩短平均完成时间。设置方法如下：
* 让启动子代理的工具立即返回。
* 在每个子代理的结果就绪后，通过后续的 `user` 消息将其传回给主代理。
* 为主代理提供一个单独的工具，供其在想要等待结果时调用。
模型仍然经常选择等待。节省的时间来自它继续处理其他工作的那些运行。
## 为视觉任务提供裁剪和缩放工具
Claude Fable 5.1 开箱即具备更强的视觉能力，在处理密集图表等复杂视觉输入时，如果能够迭代地分析、裁剪并以视觉方式核实所见内容，它的表现最佳。要充分发挥这一优势，请将模型作为智能体运行，并让它能够访问一个容器，该容器中存放原始图像或视频，并预装了基本的图像处理库（例如 PIL 和 OpenCV）。如果运行容器的开销过大，仅提供一个图像裁剪工具就能带来大部分提升：一个返回图像中选定区域（经裁剪和放大）的工具，能让模型更深入地检查特定细节，并随图像令牌扩展测试时计算量。[裁剪工具示例](https://platform.claude.com/cookbook/multimodal-crop-tool)中提供了一个可用的定义。