GPT-5.6 (Sol) and Claude Fable 5: The 2026 Prompting Guide

Model Families at a Glance

Both releases changed more than the model itself. GPT-5.6 introduced a new naming scheme, and Claude Fable 5 ships alongside a sibling model, Claude Mythos 5. Here is the map before we get into prompting.

The 2026 Shift: Prompt Less, Not More

If you take one idea from this guide, take this: both labs are telling you to remove instructions, not add them.

OpenAI reports that in internal evaluations, replacing long, explicit system prompts with minimal prompts improved scores by roughly 10–15% while cutting total tokens by 41–66% and cost by 33–67%. Many older prompt instructions have simply become default model behavior, so the largest gains come from focusing only on the behavior the model does not perform naturally.

Anthropic frames the same idea from the capability side: Claude Fable 5's instruction-following is strong enough that you can steer most behaviors with a brief instruction rather than enumerating each behavior by name. It also warns that skills and prompts built for older models are "often too prescriptive for Claude Fable 5 and can degrade output quality."

So the modern workflow is subtractive. Start small, benchmark on representative tasks, and add an instruction, tool, or example only when an evaluation reveals a specific gap.

Prompting Claude Fable 5

Claude Fable 5 takes on problems that were previously too complex, long-running, or ambiguous for prior models, and it is particularly effective at end-to-end work that takes a person hours, days, or weeks. Teams that see the best results point it at their hardest unsolved problems. Here is how to prompt and scaffold it.

1. Set effort deliberately

Effort is the primary control for the trade-off between intelligence, latency, and cost. Use high as the default, xhigh for the most capability-sensitive workloads, and medium or low for routine work. Lower effort settings on Fable 5 still perform well and often exceed xhigh on prior models. Reduce effort if a task completes but takes longer than necessary, or if you want a quicker, more interactive style.

At higher effort, Fable 5 can gather context and deliberate beyond what a routine task needs. To prevent unrequested tidying or refactoring, tell it so directly:

Don't add features, refactor, or introduce abstractions beyond what the task
requires. A bug fix doesn't need surrounding cleanup and a one-shot operation
usually doesn't need a helper. Do the simplest thing that works well. Only
validate at system boundaries (user input, external APIs); trust internal code
and framework guarantees.

2. Steer with one brief instruction, not a checklist

Because instruction-following is strong, a single short instruction is as effective as listing every pattern by name. For brevity and readability, the official guidance is to prioritize the outcome rather than compress the writing:

Lead with the outcome. Your first sentence after finishing should answer "what
happened" or "what did you find": the thing the user would ask for if they said
"just give me the TLDR." Supporting detail and reasoning come after. Being
readable and being concise are different things, and readability matters more.

The way to keep output short is to be selective about what you include, not to
compress the writing into fragments, abbreviations, or arrow chains like
A -> B -> fails.

3. Plan for longer turns

Individual requests on hard tasks can run for many minutes at higher effort, and autonomous runs can extend for hours. Adjust client timeouts, streaming, and progress indicators before migrating, and consider restructuring harnesses to check on runs asynchronously rather than blocking. To keep Fable 5 from over-planning ambiguous tasks:

When you have enough information to act, act. Do not re-derive facts already
established in the conversation, re-litigate a decision the user has already
made, or narrate options you will not pursue. If you are weighing a choice,
give a recommendation, not an exhaustive survey.

4. Ground progress claims during long runs

On long autonomous runs, instruct Fable 5 to audit progress against actual tool results. In Anthropic's testing this nearly eliminated fabricated status reports, even on tasks designed to provoke them:

Before reporting progress, audit each claim against a tool result from this
session. Only report work you can point to evidence for; if something is not yet
verified, say so explicitly. If tests fail, say so with the output; if a step
was skipped, say that; when something is done and verified, state it plainly
without hedging.

5. State the boundaries

Fable 5 can occasionally take unrequested actions — drafting an email nobody asked for, or creating defensive git-branch backups. Define what it should and should not do:

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 running a
command that changes system state, check that the evidence actually supports
that specific action.

6. Use parallel subagents and a memory file

Fable 5 dispatches parallel subagents more readily than prior models and is more dependable at sustaining them. Prefer asynchronous communication between the orchestrator and its subagents over blocking until each returns. It also performs particularly well when it can record and reference lessons from previous runs — something as simple as a Markdown file works:

Store one lesson per file with a one-line summary at the top. Record corrections
and confirmed approaches alike, including why they mattered. Don't save what the
repo or chat history already records; update an existing note rather than
creating a duplicate; delete notes that turn out to be wrong.

7. Handle rare early stopping and context worries

Deep into a long session, Fable 5 can occasionally end a turn with a statement of intent ("I'll now run X") without issuing the tool call, or pause to ask permission when it already has enough to proceed. For autonomous pipelines, a system reminder fixes this:

You are operating autonomously. The user is not watching in real time and cannot
answer questions mid-task, so asking "Want me to...?" will block the work. For
reversible actions that follow from the original request, proceed without asking.
Before ending your turn, check your last paragraph. If it is a plan, a question,
or a promise about work you have not done, do that work now with tool calls. End
your turn only when the task is complete or you are blocked on input only the
user can provide.

In very long sessions Fable 5 can also suggest a new session or offer to summarize and hand off, usually when the harness shows a remaining-token countdown. Avoid surfacing explicit context-budget counts; if you must, reassure it: "You have ample context remaining. Do not stop, summarize, or suggest a new session on account of context limits. Continue the work."

8. Give the reason, not only the request

Fable 5 performs better when it understands intent, because context lets it connect the task to relevant information instead of guessing. A simple frame helps, especially for long-running agents: "I'm working on [the larger task] for [who it's for]. They need [what the output enables]. With that in mind: [request]."

9. Scaffolding changes worth making

• Start at the top of your difficulty range. Pick a task harder than you'd give prior models, and have Fable 5 scope it, ask clarifying questions, and execute.
• Make verification explicit. Separate, fresh-context verifier subagents tend to beat self-critique. Instruct: "Establish a method for checking your own work at an interval as you build. Run this every [interval], verifying against the specification with subagents."
• Refactor old prompts and skills. Instructions tuned for prior models are often too prescriptive and can degrade output. Remove what's now default behavior.
• Don't ask Claude to reproduce its reasoning in the response. Instructions to echo, transcribe, or explain internal reasoning as response text can trigger the reasoning_extraction refusal category and cause elevated fallbacks. If you need reasoning visibility, read the structured thinking blocks instead.
• Add a send_to_user tool for long async agents (below).

10. The send_to_user pattern

For long, asynchronous agents, give the model a way to surface a message the user must see verbatim without ending its turn — a deliverable, a progress update with specific numbers, or a direct reply to a mid-loop question. Tool inputs are never summarized, so the content arrives intact.

{
  "name": "send_to_user",
  "description": "Display a message directly to the user. Use this for progress updates, partial results, or content the user must see exactly as written before the task finishes.",
  "input_schema": {
    "type": "object",
    "properties": {
      "message": {
        "type": "string",
        "description": "The content to display to the user."
      }
    },
    "required": ["message"]
  }
}

Defining the tool is not enough on its own — pair it with an instruction such as: "Between tool calls, when you have content the user must read verbatim, call the send_to_user tool with that content. Use it only for user-facing content, not for narration or reasoning."

Prompting GPT-5.6 (Sol)

GPT-5.6 sets a new quality and efficiency baseline for complex production workflows. It is especially token-efficient and noticeably better at frontend aesthetics — layout, visual hierarchy, and design judgment. Treat migration as a tuning pass, not just a slug swap.

1. Pick the right model in the family

Use gpt-5.6-sol for frontier capability (the gpt-5.6 alias routes here), gpt-5.6-terra for a balance of intelligence and cost, and gpt-5.6-luna for efficient, high-volume workloads. Use the Responses API for reasoning, tool-calling, and multi-turn workflows.

2. Set reasoning effort intentionally

GPT-5.6 supports none, low, medium, high, xhigh, and max. If you're migrating from GPT-5.5 or GPT-5.4, preserve your current effort as the baseline, then test one level lower — GPT-5.6 can often match or improve quality with fewer tokens.

3. Use shorter prompts

This is the headline GPT-5.6 change. Removing redundant instructions, examples, and verbose tool descriptions produced clearer efficiency gains than adding model-specific guidance. Heavier prompts encourage extra exploration, repeated validation, and larger accumulated context.

• Start with the smallest prompt and tool set that reliably completes the task.
• Expose only task-relevant tools, and keep tool descriptions concise and precise.
• Use examples and style guidance sparingly. Avoid repeated phrasing or "X, not Y" patterns the model may mirror.
• Monitor both starting and accumulated context.

4. Don't say "be concise"

GPT-5.6 is more sensitive than GPT-5.5 to instructions like "be concise" or "use minimal text." Because it is already biased toward compression, such an instruction can change how it prioritizes the task — it may decide a shorter substitute is preferable to producing the full requested artifact. Replace brevity with prioritization:

Lead with the conclusion. Include the evidence needed to support it, any material
caveat, and the next action. Omit secondary detail and repetition.

Keep all required facts, decisions, caveats, and next steps. Trim introductions,
repetition, generic reassurance, and optional background first.

The same principle applies to warmth. Don't ask GPT-5.6 to be "friendly and warm"; give concrete guidance: "Be direct and tactful. Acknowledge friction specifically when relevant. Avoid canned reassurance and unnecessary sign-offs." And keep structure guidance lightweight — a small task-specific outline, not a global response template.

5. Define autonomy and permissions clearly

GPT-5.6 can be proactive and persistent, so define what each request authorizes. A compact policy is usually enough — and repeating "ask first" or "do not mutate" throughout the prompt can actually cause unnecessary permission checks even for safe actions.

For requests to answer, explain, review, diagnose, or plan, inspect the relevant
materials and report the result. Do not implement changes unless the request also
asks for them.

For requests to change, build, or fix, make the requested in-scope local changes
and run relevant non-destructive validation without asking first.

Require confirmation for external writes, destructive actions, purchases, or a
material expansion of scope.

6. Reach for pro mode only when it pays

Pro mode (reasoning.mode: "pro" in the Responses API) applies more model work before returning a single answer. Use it when a marginal quality improvement materially affects the outcome and the task is hard enough to benefit — complex optimization, high-value coding or review, deep analysis with clear evaluation criteria. Prefer standard mode for routine, latency-sensitive, or high-volume work.

Enable it in the API request, not in the prompt. You don't need to tell the model to "use pro mode," "think harder," or generate several candidates. Give it the same outcome-focused prompt you would use in standard mode: goal, context, constraints, required evidence, success criteria, and output format. Reasoning mode and reasoning effort are independent; if you omit effort, GPT-5.6 defaults to medium in both modes.

7. Use Programmatic Tool Calling for bounded, tool-heavy stages

Programmatic Tool Calling (PTC) lets GPT-5.6 write JavaScript to call eligible tools, pass results between calls, and process intermediate outputs in a hosted runtime. It works best for bounded workflows where code can process several tool results or large intermediate outputs and return a much smaller structured result — filtering, joining, ranking, deduplication, aggregation, or validation.

Multiple, parallel, or dependent calls alone do not justify PTC. Prefer direct tool calls when one call is enough, intermediate outputs are already small, each result may change the model's next decision, an action needs approval, or the output must preserve citations. When both routes are available, be explicit about the handoff:

<tool_orchestration>
Use Programmatic Tool Calling for [bounded stage] using only [eligible tools].
Run independent calls concurrently when safe. Use only documented tool input
and output fields.

Process and reduce the intermediate results, then emit exactly [output schema],
including the evidence needed for the final answer.

Stop when [condition] is met. Retry transient failures at most [R] times.
Do not repeat completed calls or perform side-effecting actions.

Use direct tool calls for [semantic judgment, approval, or final validation].
</tool_orchestration>

8. Persisted reasoning and prompt caching

GPT-5.6 can reuse reasoning items across turns to improve multi-turn quality and cache efficiency. Set reasoning.context to all_turns when the task's goals and priorities stay stable across turns (and continue with previous_response_id), or current_turn when earlier reasoning is no longer relevant. Omit it or use auto for the model default.

On caching: GPT-5.6 lets you mark exactly which reusable prompt prefixes are cached. Because cache writes cost 1.25× the uncached input rate while reads stay discounted, track cached_tokens and cache-write tokens to understand net cost, and use explicit breakpoints to avoid unnecessary writes. Beyond these, GPT-5.6 also ships Multi-agent orchestration (beta, Responses API) for tasks that divide cleanly into independent workstreams, and it preserves the original dimensions of images sent with original or auto detail (which can raise input tokens and latency for large images).

Head-to-Head: The Same Problems, Two Answers

The models converge on principles but differ in the exact levers. This table is the quick reference most teams actually need.

Five Principles That Work on Both

1. Prompt subtractively. Both labs found that removing instructions the model already follows improves quality. Add only what closes a measured gap.
2. Prioritize, don't compress. "Lead with the outcome/conclusion" beats "be concise" on both models — and on GPT-5.6, "be concise" can actively backfire.
3. State intent and boundaries once. Give the reason behind a request, and define permissions clearly — but don't repeat the same guardrail throughout the prompt.
4. Verify with fresh context. Separate verifier subagents (Fable 5) and explicit evidence/output schemas (GPT-5.6 PTC) both beat asking the model to grade its own work inline.
5. Benchmark every change. Fewer tokens, calls, or turns are improvements only when the final user-visible answer still meets the quality bar.

Copy-Paste Prompt Snippets

These are drawn directly from the official guidance and are safe starting points. Trim them to fit — remember, both models prefer the shortest version that works.

Lead with the conclusion: one sentence on what happened or what you found.
Then the evidence that supports it, any material caveat, and the next action.
Keep all required facts, decisions, and next steps; trim introductions,
repetition, and generic reassurance.

You are operating autonomously; the user cannot answer mid-task. For reversible
actions that follow from the request, proceed without asking.

Before reporting progress, audit each claim against a tool result from this
session. Report only work you can point to evidence for.

Establish a way to check your own work as you build, and verify against the
specification with fresh-context subagents at a regular interval.

Before ending your turn, if your last paragraph is a plan, a question, or a
promise about undone work, do that work now with tool calls.

For requests to answer, explain, review, or plan, inspect the materials and
report the result. Do not implement changes unless asked.

For requests to change, build, or fix, make the in-scope local changes and run
non-destructive validation without asking first. Require confirmation for
external writes, destructive actions, or a material expansion of scope.

Lead with the conclusion; include supporting evidence, caveats, and next steps.

Migration Checklist

• Re-run your evals with the same effort as your old model, then one level lower.
• Delete instructions the new model already follows by default.
• Replace every "be concise" with a "lead with the conclusion" prioritization line.
• Adjust client timeouts and streaming for longer turns (Fable 5) and mid-stream safeguard pauses (GPT-5.6).
• Configure fallback to Claude Opus 4.8 for Fable 5 refusals; send a safety_identifier on GPT-5.6.
• Audit skills/prompts for "show your reasoning" instructions (Fable 5 refusal risk).
• Decide PTC vs direct tool calls (GPT-5.6) and async subagents vs blocking (Fable 5).
• Benchmark task success, tokens, latency, and cost — not just token count.