Prompting Claude Opus 5.5

Behavioral differences from Claude Opus 5 and the prompting and harness patterns that address them: effort calibration, thinking behavior in API integrations and chat, progress updates, unattended and multiagent tasks, safeguard refusals, frontend design, complex visual inputs, multi-app workflows, and pasted text in user messages.

This guide covers the prompting patterns specific to Claude Opus 5.5. For the model's capabilities and API changes, see What's new in Claude Opus 5.5. For techniques that apply across all current Claude models, see Prompting best practices.

Claude Opus 5.5 generates output tokens more than 30 percent faster than Claude Opus 5 and tends to finish the same task with fewer tokens. Existing Claude Opus 5 prompts should perform well without changes, and the patterns in Prompting Claude Opus 5 remain a reasonable starting point. Start with the section that matches what you observe:

• Unsure which effort level to run, or turns run longer and cost more than they did on Claude Opus 5: Calibrate effort
• Your Claude Opus 5 integration ran with thinking disabled: Prompts written for thinking disabled
• An unattended agent stops partway through a long task after reporting progress: Unattended agentic runs
• Requests return stop_reason: "refusal": Safeguard refusals
• Long agentic turns look silent, or you want updates at predictable points: User-facing progress updates
• An agent that works across several connected apps misses information the task didn't point to: Explore context in multi-app workflows
• You run a team of agents and want it to finish sooner: Time signals for multiagent harnesses
• Replies in a chat application start slowly because the model thinks at length first: Thinking instructions in chat system prompts
• The model follows instructions that arrived inside text a user pasted: Mark pasted text in user messages
• Answers about dense charts, diagrams, or screenshots miss detail: Tools for complex visual inputs
• Frontend output looks generic: Frontend design defaults

Capabilities relevant to prompting

The capabilities that matter most for prompting are:

• Agentic coding and code review: The model is strongest on multistep work in a real repository, such as carrying a change through a large code base until its tests pass. In Anthropic's testing, at its default medium effort the model matched or beat Claude Opus 5 at high effort on such tasks, in fewer steps and with fewer tokens. It also sustains long-running autonomous work better than Claude Opus 5, such as multi-hour audits and migrations of large code bases run end to end with parallel subagents and little oversight. Early testers also reported stronger code review, with more bugs caught than on Claude Opus 5 and fewer false alarms, and it explains its changes in plain language.
• Knowledge work: The model is much less likely to state an incorrect figure or cite the wrong source. It's better at financial modeling tasks, such as building a financial model and one-page summary for a transaction or finding and fixing errors in a valuation workbook, and it catches details that are easy to miss in large inputs, such as a date in a long planning thread that falls on the wrong weekday or a chart in a slide deck that doesn't match the underlying figures. The spreadsheets, slides, and documents it produces need less editing before you share them.
• Communication: Its reports on agentic work, both the updates while it works and the summary when it finishes, say plainly what it did, what it found, and what it needs from you. See User-facing progress updates.
• Charts, diagrams, screenshots, and computer use: The model reads visual material more accurately than Claude Opus 5 without extra tooling: in Anthropic's testing, even at its lowest effort setting it read values off dense charts more accurately than Claude Opus 5 did at its highest, using a small fraction of the output tokens. It is better, too, where meaning depends on position rather than text: which boxes an arrow connects in a flowchart, what changed between two versions of a diagram, or exactly when a meeting starts and ends in a calendar screenshot. It's also more reliable at computer use, where it operates applications from screenshots over many steps: at its default effort it matched the success rate that Claude Opus 5 reached only at a much higher effort setting. See Tools for complex visual inputs.

Calibrate effort

Effort is the main control for how much Claude Opus 5.5 thinks, and because thinking is always on, it's the first setting to adjust when trading off intelligence, latency, and cost. Start at medium, the default on Claude Opus 5.5 (Claude Opus 5 defaults to high), set it explicitly, and test several levels against your own evals rather than carrying over the setting you used on Claude Opus 5. Effort level names don't correspond to the same amount of thinking across models: in Anthropic's testing, Claude Opus 5.5 at medium matches or exceeds Claude Opus 5 at high on coding and knowledge-work evaluations, and on several coding evaluations low comes close to it at much lower cost. See Recommended effort levels for Claude Opus 5.5.

At a given level, Claude Opus 5.5 tends to think more per turn than Claude Opus 5, especially at xhigh and max. If you keep the effort value you set for Claude Opus 5, expect longer turns and more output tokens. Three adjustments help:

• Set max_tokens high enough to leave room for the model's thinking tokens and the reply. Thinking counts toward max_tokens even when thinking content isn't returned to you, so a limit sized for Claude Opus 5 with thinking off can cut replies off. For the long turns that agentic coding can produce, a max_tokens of 128,000, the model's maximum, has worked well in Anthropic's testing.
• Reserve xhigh and max for work where you've measured a quality gain.
• To get less thinking, lower the effort level first. Lowering effort reduces thinking, and with it cost and latency, more reliably than prompt instructions do.

Changing the top-level effort value between requests invalidates the prompt cache. To run individual turns at a different level, use a per-message effort change (beta) instead, which keeps the cache.

Prompts written for thinking disabled

Claude Opus 5 accepts thinking: {"type": "disabled"} at high effort or below; Claude Opus 5.5 doesn't, and the migration guide covers the request change. If your Claude Opus 5 integration ran with thinking disabled, four changes go with it:

• Start at low effort and measure. At low the model keeps its thinking short. How often it skips thinking altogether depends on your prompts, so measure latency and quality on your own traffic and move to medium if quality drops. If time to first token still matters after that, a system prompt line such as "Answer directly without deliberating." can reduce thinking further; measure quality when you add it, because less thinking can lower it.
• Remove instructions that stood in for thinking. If your prompt asked the model to write out its reasoning in the response as a substitute for thinking, remove that instruction and read the reasoning from summarized thinking blocks instead (display: "summarized"); a prompt that pushes the model to reproduce its reasoning in the response text can be declined with the reasoning_extraction refusal category.
• Re-test the thinking-disabled mitigations. Running with thinking disabled recommends a combined instruction (permission to speak before a tool call, what to do when no tool fits, no internal tags) and removing any rule that tells the model not to think. Both address artifacts that appear on Claude Opus 5 only when thinking is disabled. With thinking always on, check whether you still need the instruction, and remove the no-thinking rule either way.
• Read the response by block type. Check each block's type instead of assuming the first content block is text: a response may or may not begin with a thinking block, whose thinking field is empty under the default display: "omitted".

Unattended agentic runs

On long tasks with several parts, Claude Opus 5.5 keeps the user updated as it works, and some of those updates end the turn with text rather than a tool call (stop_reason: "end_turn"). An unattended agent loop that treats such a turn as the end of the task stops running there. A few harness and prompt changes help it keep running.

Treat a text-only end of turn as a report rather than as proof the task is done. Keep the task's parts in a checklist the model updates, such as a to-do tool or a file. If a turn ends with items still open and no blocker stated, send a short user message naming them, like the following one. You can also state the completion condition up front and have a separate, smaller model check the conversation against it at each end of turn, returning its reason as the next user message when the condition isn't met. Either way, stop after two or three automatic continuations on the same task rather than repeating them indefinitely, so that a run that is genuinely stuck ends and can be reviewed.

If something the model started is still running, such as a background command or a subagent, don't treat the task as done yet: wait for it to finish and return its output to the model as the next user message.

A system prompt addition can also make these early stops less frequent. Claude Opus 5.5 is responsive to instructions that name the specific kinds of early stop you want it to avoid, such as ending the turn with a summary that announces the next step instead of taking it. It also helps to name the stops you do want, for example when no work can advance without the user's input.

The following paragraph is one example of such an addition, written for agents that run fully unattended, where you want the model to keep working rather than stop to report. Treat it as a starting point: you might need to adapt it for your own application. Add it at the end of your system prompt from the first request of the session: adding it partway through changes the system prompt and invalidates the conversation's earlier thinking blocks (see Preserved thinking). Because it tells the model to put status notes in the same message as its next tool call, those notes arrive between tool calls as progress updates, whose text comes back empty at the default thinking.display; set display: "updates" to receive a summary of each (see User-facing progress updates). With this addition the model carries on where it would otherwise have stopped to check in, so keep your own confirmation step for risky or irreversible actions, and leave the addition out of human-in-the-loop applications, where someone is there to answer. Expect somewhat more tool calls and output tokens per task.

Safeguard refusals

Claude Opus 5.5 runs safety classifiers, including for biology, cybersecurity, and reasoning extraction.

• Biology: The biology safeguards are the same as Claude Fable 5.1's and are new if you're coming from Claude Opus 5. Everyday health and educational questions are unaffected. If the biology classifier gets in the way of your organization's life sciences work, apply to the Life Sciences Verification Program.
• Cybersecurity: Finding vulnerabilities in source code is allowed. High-risk dual-use cybersecurity activities are not.
• Reasoning extraction: Requests that push the model to reproduce its internal reasoning in the response text can be declined with the reasoning_extraction category, which is new if you're coming from Claude Opus 5. If your prompts ask the model to write out its reasoning in the response, remove those instructions, set display: "summarized", and read the summarized reasoning from the thinking blocks instead; see Prompts written for thinking disabled.

A classifier decline arrives as a normal response with stop_reason: "refusal" and a stop_details object naming the category. You can have the request retried automatically on a fallback model, except for reasoning_extraction declines, which server-side fallback returns to you instead of retrying; see Refusals and fallback.

User-facing progress updates

Between tool calls, Claude Opus 5.5 writes short user-facing progress updates: what it just found and what it's doing next. Four levers control what your users see.

First, check that your client receives them: on Claude Opus 5.5 these notes come back as progress-update thinking blocks rather than text blocks, and their text is empty at the default thinking.display, so a client that renders only text blocks can look silent during a long agentic turn. Set display: "updates" (beta, thinking-display-updates-2026-08-18 header) to receive a short summary of each note; the migration guide shows how to render them.

Second, if the model may need to hand the user something verbatim partway through a long turn, such as a code snippet, give it a simple tool for sending the user a message and tell it to reserve the tool for that content. Declare the tool in tools from the first request of the session: adding it to tools later edits the conversation's prefix and invalidates earlier thinking blocks (see Preserved thinking).

Third, if you want more frequent or predictable updates, such as a one-line statement of intent before the first tool call and a short recap at the end, say so in the system prompt; the model is responsive to such instructions. This helps most in human-in-the-loop work.

Fourth, if long tool-calling turns still go quiet for longer than you want, have your harness ask for an update. With display: "updates" set (the first lever), count consecutive tool-calling steps that give the user nothing to read: no text block and no progress-update text. After several in a row (five, for example), append a reminder like the following one after the latest tool results, as a turn-scoped system message (clear_at: "next_user_message"; beta, mid-conversation-system-clear-at-2026-08-21 header). If the turn stays quiet, stop after two or three reminders rather than sending more. Because each reminder is appended and left in place, rather than inserted for one request and deleted on the next, the prompt cache keeps matching and the thinking blocks that follow it stay valid. In Anthropic's testing on agentic coding tasks, this roughly halved the share of tasks with a long silent stretch, with no measurable change in cost.

Explore context in multi-app workflows

In workflow automation across several connected apps, such as email, documents, spreadsheets, and CRM records, the information a task depends on often sits somewhere the request doesn't explicitly mention: for example, a policy in an old email thread, a rule on another spreadsheet tab, or a note on a customer record. Claude Opus 5.5 tends to get to work quickly, and on loosely specified tasks it helps to tell the model to look through the relevant sources before acting. If your agent works across several apps on tasks like these, one sentence in the system prompt makes it look around before it changes anything:

In Anthropic's testing on multi-app automation tasks, Claude Opus 5.5 completed noticeably more of them correctly with this instruction, at both medium and max effort, at the cost of slightly more tool calls and tokens. Because it tells the model to act on what it finds, keep untrusted content out of the records it searches.

Time signals for multiagent harnesses

Claude Opus 5.5 pays close attention to information about elapsed time, and in a multiagent setup, for example a lead agent that delegates to subagents, you can use that to speed up the work through better parallelization. If you can estimate how long the task should take, give the model a time budget: have your harness add a short line at the end of each message it sends back to the model giving the elapsed time against that budget, in seconds, for example elapsed 340s / 1200s. The model paces its work to finish inside the budget and usually finishes well before it, so set the budget somewhat above the time you actually want spent and tune it on a sample of your own tasks. If you can't predict a sensible budget, show the elapsed time alone and add one sentence to the system prompt:

In Anthropic's evaluations of small agent teams on research tasks, both signals made teams finish sooner than a single agent working without them. Teams given a budget kept answer quality comparable to the single agent's while finishing considerably sooner. A tighter budget has a different effect from a lower effort setting: lowering effort reduces the work itself, whereas a budget mostly keeps more agents working in parallel. The budget is advisory and nothing stops the model at the limit, so if you need a hard stop, keep your own timeout. Also check answer quality on your own tasks, because under time pressure the model might search and verify a little less.

Thinking instructions in chat system prompts

In chat applications, if your system prompt contains instructions that tell Claude to think carefully before answering, consider removing them for Claude Opus 5.5. The model decides for itself how much to think, and effort is the main control. In Anthropic's testing in a chat product, removing such a line made replies start sooner, with no clear decline in the quality of the reply.

In multi-turn chat, Claude Opus 5.5 sometimes goes back over an earlier answer while it thinks about a new message, even a short follow-up, which adds thinking and latency on later turns. If you would rather the model treat earlier answers as settled, add two sentences at the end of the system prompt:

In Anthropic's testing this reduced thinking on follow-up turns and made replies start sooner without affecting quality. Leave it out where you want the model to keep re-examining its earlier work, for example in long analyses, or in agentic tasks where a later step can reveal a mistake in an earlier one. The instruction may also make the model less likely to point out a mistake in an earlier answer on its own, so if that matters for your application, test for it before adopting the instruction.

Mark pasted text in user messages

Claude Opus 5.5 resists indirect prompt injection, meaning instructions that arrive through tool results, web pages, and on-screen or browser content, better than any earlier Opus model. With the right context it is also robust against instructions inside content a user copied into their message from elsewhere, such as an email or a web page. To get that behavior, mark which text is the user's own and which was pasted from somewhere else. Wrap each pasted block in an opening and a closing tag that both carry the same short random ID, generated by your application, with each tag on its own line:

Then add this note to your system prompt:

This can make the model slightly more cautious at times, so measure the effect on your own tasks. The tags are plain text and can be imitated, so treat this as one guardrail alongside other prompt-injection defenses.

Tools for complex visual inputs

Because Claude Opus 5.5 reads charts, diagrams, and screenshots considerably more precisely than Claude Opus 5 without tools (see Capabilities relevant to prompting), re-test whether you still need scaffolding you built for visual inputs on earlier models. For the densest inputs, two things still add accuracy. Higher-resolution images help, most of all for inputs like technical drawings. So do image-processing tools: run the model as an agent with access to a container that holds the raw images and has libraries such as PIL and OpenCV installed, so that it can crop, zoom, measure, and verify its work. If a container is too much overhead, a cropping tool alone still helps; the crop tool recipe has a working definition. The model uses these tools more effectively at higher effort levels. Without tools, raising effort improves its reading of technical drawings but does little for charts.

Frontend design defaults

Asked for frontend work without design direction, Claude Opus 5.5 falls back on a few default styles, and a general instruction such as "avoid a generic AI look" mostly swaps one default for another. It responds well to instructions that name specific patterns to avoid, as in the following example. Work iteratively: check which styles the first result used instead, and extend the list if needed.