Abstract. Claude Extended Thinking is Anthropic’s attempt to productize Test-Time Compute as an explicit reasoning mode: the model spends additional output-token budget on structured thinking before emitting its final response, and the API treats that reasoning as a first-class content block rather than a purely hidden implementation detail. The architecture evolved from Claude 3.7 Sonnet’s visible raw thinking into Claude 4’s summarized/encrypted thinking blocks and Claude Opus 4.7’s adaptive, effort-controlled, often omitted-by-default thinking path, creating a distinct design tradeoff against OpenAI’s hidden chain-of-thought approach.
Coverage note: verified through May 11, 2026.
Claude Extended Thinking: Anthropic’s Reasoning Architecture
Core claim
Claude Extended Thinking is not merely “chain-of-thought prompting with a better prompt.” It is an API and product architecture for Reasoning Models: a single Claude model can run in a low-latency response mode or spend additional inference-time compute on reasoning, with explicit controls over thinking depth, display policy, tool interleaving, and continuity across tool calls. Anthropic’s original differentiator was visible reasoning; by Claude 4.x and Opus 4.7, the differentiator became more subtle: structured thinking state is still part of the API contract, but raw visibility has been narrowed through summaries, encrypted signatures, omitted display modes, and adaptive effort controls. Anthropic introduced Claude 3.7 Sonnet as a “hybrid reasoning model” able to answer quickly or produce visible extended step-by-step thinking, while Claude 4 added extended thinking with tool use and Claude Opus 4.7 removed manual budgets in favor of adaptive thinking plus effort levels. anthropic.com+2anthropic.com+2
What extended thinking is
In Anthropic’s API, extended thinking means that Claude produces thinking content blocks before text content blocks. The thinking block is not just prose emitted in the final answer; it is a distinct response element with its own type, reasoning text or summary, and a signature field used to preserve reasoning continuity in later turns. Anthropic’s documentation says that when extended thinking is enabled, Claude creates thinking blocks where it outputs internal reasoning, incorporates insights from that reasoning, and then emits final text blocks. Claude Platform
This matters because it makes Reasoning State a protocol-level object. A harness can distinguish planning from final output, stream reasoning separately, omit reasoning display while preserving a cryptographic/encrypted signature, and pass thinking blocks back during tool loops. In older Claude 3.7 behavior, this looked like visible raw thinking; in Claude 4 models, Anthropic generally returns a summary of full thinking; in Claude Opus 4.7, the default is to omit thinking text unless the caller explicitly asks for summarized display. Claude Platform
The common phrase “thinking budget” is conceptually right but API-specific. In manual mode, the actual Messages API field is thinking: { "type": "enabled", "budget_tokens": N }, not a top-level thinking_budget parameter. In Claude Opus 4.7, that manual budget_tokens path is no longer supported; the replacement is thinking: { "type": "adaptive" } plus output_config.effort. Claude Platform+2Claude Platform+2
Evolution across Claude 3.7, Claude 4, and Opus 4.7
| Release | Reasoning architecture change | Practical consequence |
|---|---|---|
| Claude 3.7 Sonnet — Feb. 24, 2025 | Introduced Anthropic’s first hybrid reasoning model: near-instant responses or visible extended thinking, with API control over how long the model could think. | Developers could trade speed and cost for quality using a bounded thinking budget; users could see raw thought traces in supported surfaces. anthropic.com |
| Claude 4 — May 22, 2025 | Added Claude Opus 4 and Sonnet 4 as hybrid models, plus extended thinking with tool use, allowing Claude to alternate between reasoning and tools. | Agent harnesses could let Claude reason, call tools, reason over tool results, and continue, rather than treating planning and tool use as separate prompt phases. anthropic.com |
| Claude 4 API refinement — May 2025 onward | Claude 4 defaulted to summarized thinking rather than full raw thinking; full thinking was encrypted in the signature field. |
Visibility shifted from raw chain-of-thought toward controlled summaries and structured reasoning state. Claude API Docs |
| Display control — Mar. 16, 2026 | Anthropic added thinking.display: "omitted" so callers could suppress thinking text while preserving the signature for continuity. |
Backend or latency-sensitive apps could avoid streaming reasoning tokens to users, reducing time-to-first-final-text but not billing. Claude API Docs |
| Claude Opus 4.7 — Apr. 16, 2026 | Manual extended thinking was removed; adaptive thinking became the only thinking mode for Opus 4.7, controlled by effort levels including the new xhigh. |
Developers moved from hard per-request thinking budgets toward model-adaptive reasoning effort, especially for long-running coding and agentic workloads. anthropic.com |
This timeline shows a real design shift. Anthropic began with “visible raw thinking” as a major differentiator. By Opus 4.7, the public API still exposes structured thinking blocks, but the default user-visible behavior is often summarized or omitted. The differentiator is therefore no longer simply “Claude shows the chain of thought”; it is “Claude exposes a controllable reasoning substrate.” anthropic.com+2Claude Platform+2
API semantics
Manual extended thinking
Manual extended thinking is the older API form. A caller sets:
{ "thinking": { "type": "enabled", "budget_tokens": 32000 }, "max_tokens": 64000}
In this mode, budget_tokens is the maximum number of tokens Claude may use for internal reasoning. Anthropic states that larger budgets can improve response quality on complex problems, though the model may not use the full allocation, especially at higher ranges. The budget must be less than max_tokens, except in interleaved-thinking tool loops where the accounting changes because budget can apply across thinking blocks within one assistant turn. Claude Platform
Manual mode is now a legacy-compatible path rather than Anthropic’s preferred path for frontier Opus/Sonnet models. It remains supported on current Claude models except Opus 4.7, but it is deprecated on Opus 4.6 and Sonnet 4.6. Opus 4.7 rejects manual thinking: { "type": "enabled", "budget_tokens": N } with a 400 error. Claude Platform
Adaptive thinking and effort
Adaptive thinking lets Claude decide whether and how much to think based on request complexity. Anthropic recommends it for Opus 4.7, Opus 4.6, and Sonnet 4.6, and describes it as better than fixed budgets for many workloads, especially bimodal tasks and long-horizon agentic workflows. Opus 4.7 supports adaptive thinking as its only thinking mode, but thinking is still off unless the request explicitly sets thinking: { "type": "adaptive" }. Claude Platform
Effort is the companion control. Anthropic’s effort parameter controls how eager Claude is to spend tokens, trading response thoroughness against token efficiency. It affects final text, tool calls, function arguments, and extended thinking when thinking is enabled. Supported levels include low, medium, high, max, and for Opus 4.7, xhigh, which Anthropic positions for long-running coding and agentic tasks with large token budgets. Claude Platform
| Mode | Control surface | Supported direction | Best use |
|---|---|---|---|
| No thinking | Omit thinking, or use disabled mode where supported | Lowest latency and cost | Everyday chat, classification, simple edits |
| Manual extended thinking | thinking.type = "enabled", budget_tokens = N |
Fixed upper bound on reasoning tokens | Legacy systems needing predictable reasoning ceilings |
| Adaptive thinking | thinking.type = "adaptive" |
Model decides when and how much to think | Mixed workloads, agents, coding, long-horizon tasks |
| Effort control | output_config.effort |
Behavioral/token-spend signal, not a strict budget | Tuning quality, verbosity, tool usage, and cost |
Thinking blocks versus final response
The API response structure is ordered: thinking blocks first, final text blocks later. In Claude 4 models, the thinking content visible to the caller is generally summarized rather than raw; the full thinking is represented in the signature for continuity and validation. In Opus 4.7, display defaults to "omitted", so the API can return a thinking block with an empty thinking field and a preserved signature. Claude Platform
This distinction is central for User Interface Design for AI Agents. A user-facing app can choose to show summarized reasoning for trust and progress feedback, omit thinking for faster final-answer streaming, or preserve thinking invisibly for tool-loop continuity. Omitting display does not reduce cost: Anthropic explicitly says callers are still charged for full thinking tokens; omitted display reduces latency, not billing. Claude Platform
Streaming
When streaming is enabled and thinking display is not omitted, Anthropic emits thinking_delta events before text_delta events. With display: "omitted", no thinking_delta events are emitted; the stream receives the signature and then proceeds to final text. This gives product teams a clean knob for whether users see a progress-like reasoning stream or wait for final output. Claude Platform
Tool use and interleaved thinking
Extended thinking with Tool Use has stricter semantics than ordinary message continuation. Anthropic allows thinking with tool_choice: "auto" or tool_choice: "none" but not forced tool use, because forcing a specific tool is incompatible with extended thinking. During tool use, developers must pass the complete unmodified thinking blocks back to the API for the last assistant message to maintain reasoning continuity. Claude Platform
Claude 4 models support Interleaved Thinking, meaning Claude can reason between tool calls after receiving intermediate tool results. Opus 4.7 automatically enables interleaved thinking when using adaptive thinking; older Claude 4 models used the interleaved-thinking-2025-05-14 beta header. The agentic implication is large: the model can use a tool, inspect the result, update its plan, call another tool, and continue within a single conceptual assistant turn. Claude Platform
Thinking-state preservation
Thinking blocks are not arbitrary scratchpad text a client can rewrite. Anthropic says the entire sequence of consecutive thinking blocks must match the original model output and cannot be rearranged or modified. The reason is not only validation; it is distributional continuity. From Claude’s perspective, a tool loop is part of one continuous assistant response, even though it may appear as multiple API messages. Claude Platform
This is one of the most important harness-design details. If your agent framework strips reasoning state, mutates it, or toggles thinking mode mid-turn, you are not merely hiding irrelevant output; you may be breaking the model’s intended reasoning flow. Anthropic’s docs explicitly advise planning the thinking strategy at the start of a turn rather than toggling mid-turn. Claude Platform
Empirical results: enabled versus disabled
The cleanest public on/off comparison is Claude 3.7 Sonnet. Anthropic’s launch table compared Claude 3.7 Sonnet with a 64K extended-thinking setting against Claude 3.7 Sonnet without extended thinking across several benchmarks. The largest gains were on math and science-style reasoning, while smaller but still visible gains appeared on instruction following, multilingual Q&A, and visual reasoning. anthropic.com
| Benchmark | No extended thinking | 64K extended thinking | Observed pattern |
|---|---|---|---|
| GPQA Diamond | 68.0% | 78.2% / 84.8% | Large science-reasoning gain; higher figure involved additional evaluation method noted by Anthropic. |
| MMMLU | 83.2% | 86.1% | Moderate multilingual knowledge/reasoning gain. |
| MMMU validation | 71.8% | 75.0% | Moderate multimodal reasoning gain. |
| IFEval | 90.8% | 93.2% | Smaller but meaningful instruction-following gain. |
| MATH 500 | 82.2% | 96.2% | Very large math gain. |
| AIME 2024 | 23.3% | 61.3% / 80.0% | Very large competition-math gain; higher figure involved additional evaluation method. |
The math results are the strongest evidence that extended thinking is a real inference-time capability rather than a cosmetic display feature. Anthropic separately reported that Claude 3.7 Sonnet’s AIME accuracy improved logarithmically with the number of thinking tokens, and described this as serial test-time compute. The same post reported parallel test-time-compute experiments on GPQA using 256 independent samples, a learned scoring model, and a 64K thinking budget, reaching 84.8% on GPQA, though Anthropic said that parallel scaling method was not deployed in the production model. anthropic.com
Coding and tool-use evidence is more complicated. Claude 3.7 Sonnet’s headline SWE-bench Verified score was 62.3%, or 70.3% with a custom scaffold, and its TAU-bench scores were 81.2% on retail and 58.4% on airline. But Anthropic’s table did not present those as a simple extended-thinking-on versus extended-thinking-off ablation; the coding results involve scaffolding/tooling choices, and the agentic tool-use results are reported separately. That means it is fair to say extended thinking helped Claude 3.7 broadly, but not fair to attribute every coding headline number solely to the budget_tokens switch. anthropic.com+2anthropic.com+2
Claude 4’s public reporting is less clean as an on/off table but still informative. Anthropic stated that Claude Opus 4 and Sonnet 4 benchmark results used the highest score with or without extended thinking; no extended thinking was used for SWE-bench Verified and Terminal-bench, while extended thinking up to 64K tokens was used for TAU-bench, GPQA Diamond, MMMLU, MMMU, and AIME. The appendix also gives no-extended-thinking baselines for those reasoning benchmarks, such as Opus 4 scoring 74.9% on GPQA without extended thinking and 33.9% on AIME without extended thinking. anthropic.com
Claude Opus 4.7’s public evidence is even more product- and agent-focused. Anthropic describes Opus 4.7 as a substantial improvement over Opus 4.6 for advanced software engineering, long-running tasks, instruction following, self-verification, memory, and vision; it also says Opus 4.7 thinks more at higher effort levels, especially later in agentic settings, improving reliability but producing more output tokens. However, the official release material does not provide the same transparent extended-thinking-enabled-versus-disabled ablation table that Claude 3.7 did. That is an evidence limitation, not a reason to dismiss the result. anthropic.com
How the benchmark evidence fits the reasoning literature
Claude Extended Thinking sits inside a broader Chain-of-Thought and Inference-Time Scaling literature. Wei et al. showed that generating intermediate reasoning steps can improve large-model performance on arithmetic, commonsense, and symbolic reasoning tasks. Wang et al.’s self-consistency work showed that sampling multiple reasoning paths and marginalizing over answers can significantly improve chain-of-thought performance on benchmarks including GSM8K, SVAMP, AQuA, StrategyQA, and ARC-Challenge. arXiv
The newer test-time-compute literature gives the more direct frame. Snell et al. studied inference-time compute allocation and found that compute-optimal test-time strategies can outperform best-of-N baselines by more than 4× in efficiency and, in some FLOPs-matched settings, allow smaller models with more inference compute to outperform much larger models. Claude’s extended thinking is a productized serial version of this idea: instead of changing the pretrained model, the system lets the model spend more work at inference time on hard prompts. arXiv
The specific benchmarks also matter. GPQA is intentionally hard: it contains 448 graduate-level biology, physics, and chemistry questions written by domain experts, with PhD-level experts reaching 65% accuracy and skilled non-expert validators reaching only 34% despite unrestricted web access. SWE-bench evaluates real GitHub issue resolution by requiring a model to generate a patch for a codebase, while SWE-bench Verified is a 500-instance human-validated subset. TAU-bench evaluates agents in dynamic user conversations with API tools and policy guidelines, measuring reliability across trials. These are exactly the kinds of tasks where more inference-time planning can plausibly help. arXiv+3arXiv+3swebench.com+3
Visibility: Anthropic versus OpenAI
The strongest conceptual contrast is with OpenAI o-Series Reasoning. OpenAI’s o1 system card says the o1 model family was trained with reinforcement learning to reason using chain-of-thought, and that o1 can produce a long chain-of-thought before responding. But OpenAI chose not to expose raw chains of thought to users. OpenAI
OpenAI’s rationale is explicit. In “Learning to reason with LLMs,” OpenAI argues that hidden chain-of-thought offers a unique monitoring opportunity, but says the chain-of-thought must remain free from policy-compliance and user-preference optimization pressure. OpenAI also says it does not want to make unaligned chain-of-thought directly visible to users, and therefore decided not to show raw chains of thought, instead showing a model-generated summary for o1. OpenAI
Anthropic originally chose the opposite public posture. In its Claude 3.7 extended-thinking post, Anthropic said it had decided to make Claude’s thought process visible in raw form, citing trust, alignment research, and user interest. But Anthropic also listed serious downsides: raw thoughts can be detached, incorrect, half-baked, not character-trained, possibly unfaithful, and potentially useful to jailbreakers. Anthropic explicitly said it did not know whether the visible thought process faithfully represented what was happening inside the model, and that current thought monitoring could not support strong safety claims. anthropic.com
By 2026, the two vendors had partly converged in user-visible behavior while retaining different API philosophies. OpenAI’s API documentation says reasoning tokens are not visible via the API, still occupy context-window space, and are billed as output tokens; OpenAI offers optional reasoning summaries and encrypted reasoning items for continuity. Anthropic’s Claude 4 stack similarly uses summaries, omitted display, billing for full thinking tokens, and encrypted/signature-bearing state; however, Anthropic still exposes thinking blocks as first-class content blocks in the Messages API, while OpenAI exposes raw reasoning only as hidden tokens or summarized reasoning items. Claude Platform+3OpenAI Developers+3OpenAI Developers+3
| Design axis | Anthropic Claude extended thinking | OpenAI o-series / reasoning models |
|---|---|---|
| Raw reasoning visibility | Raw in Claude 3.7; summarized or omitted by default in Claude 4.x / Opus 4.7. | Raw chain-of-thought hidden from users and API. |
| API reasoning object | thinking content blocks, signatures, display controls. |
Internal reasoning tokens; reasoning items/summaries in Responses API. |
| Cost accounting | Thinking tokens billed as output; summaries/omission do not remove billing. | Reasoning tokens billed as output and consume context space. |
| Tool continuity | Pass thinking blocks back unmodified during tool use. | Pass reasoning items back, or use encrypted reasoning items in stateless/ZDR contexts. |
| Safety philosophy | Visibility aids trust and research, but faithfulness and misuse are unresolved. | Hidden CoT preserves monitorability and avoids exposing unaligned internal traces. |
The disagreement is not simply “transparency versus secrecy.” It is a three-way tradeoff among user trust, monitorability, and optimization pressure on internal reasoning. OpenAI worries that showing or sanitizing raw chain-of-thought may reduce its value as a monitor; Anthropic initially emphasized the user and research value of visible traces, then moved toward summaries/omission as the safety and UX costs became more salient. OpenAI
Implications for agent harness design
For Agent Harness Design, extended thinking should be treated as a planning and control layer, not as decoration. A harness that uses Claude for code editing, research, tool orchestration, or long-running workflows should decide at the start of each assistant turn whether this turn needs thinking, what effort level to use, whether reasoning should be visible, and how reasoning blocks will be preserved across tools. Anthropic’s tool-use docs make this a protocol requirement by instructing developers to preserve thinking blocks and avoid mid-turn thinking-mode toggles. Claude Platform
Claude Code is the clearest production expression of this pattern. Anthropic describes Claude Code as an agentic coding tool that reads a codebase, edits files, runs commands, integrates with development tools, plans approaches, writes code across multiple files, verifies work, manages git operations, uses MCP, stores project instructions, builds auto memory, and can spawn multiple agents or background sessions. Claude
Claude Code’s settings make extended thinking operational rather than theoretical. The settings page includes alwaysThinkingEnabled, which enables extended thinking by default for sessions, and effortLevel, which persists effort across sessions with values including low, medium, high, and xhigh. Anthropic’s common-workflows documentation also recommends plan mode for reviewing a plan before edits touch disk, subagents for large codebase research, and non-interactive CLI piping for scripts and CI. Claude+2Claude+2
The design pattern that emerges is:
| Harness problem | Extended-thinking pattern |
|---|---|
| Hard problem detection | Route easy turns to normal mode or low effort; route ambiguous, high-stakes, or multi-step turns to adaptive thinking. |
| Planning before action | Let Claude think before file edits, migrations, or destructive commands; display a summarized plan if user approval matters. |
| Tool chains | Preserve thinking blocks across tool calls; let Claude interleave reasoning after tool results. |
| Context hygiene | Delegate exploratory reads to subagents so the main context receives concise findings rather than every file read. |
| Latency control | Use display: "omitted" when thinking is useful internally but should not block the UI with streamed reasoning. |
| Budget control | Use effort, max_tokens, and—where applicable—task budgets to keep long agentic runs from expanding without constraint. |
Claude Opus 4.7 changes the harness tradeoff further. Anthropic’s migration guide says Opus 4.7 uses fewer tool calls by default and more reasoning, with higher effort levels showing substantially more tool usage in agentic search and coding. It also warns that low and medium effort are more strictly respected, which is good for latency and cost but can cause under-thinking on complex tasks. For shallow reasoning on complex problems, Anthropic recommends raising effort to high or xhigh rather than trying to prompt around the issue. Claude Platform
Cost and latency tradeoffs
Extended thinking converts inference-time compute into output-token cost. Claude 3.7 Sonnet’s launch pricing was $3 per million input tokens and $15 per million output tokens, including thinking tokens. Current Anthropic pricing lists Opus 4.7 at $5 per million input tokens and $25 per million output tokens, and Sonnet 4.6 at $3 per million input tokens and $15 per million output tokens. anthropic.com
The invisible-cost problem is easy to miss. A summarized or omitted thinking block may show very few visible tokens, but Anthropic bills for the full thinking process. Likewise, OpenAI says reasoning tokens are not visible via the API but still occupy context-window space and are billed as output tokens. In both architectures, “I did not see the reasoning” does not mean “I did not pay for the reasoning.” Claude Platform
Latency has two components: time spent thinking and time spent streaming visible thinking. Anthropic’s display: "omitted" removes the second component but not the first. That is why omitted display improves time-to-first-final-text-token without reducing cost or underlying reasoning latency. Claude Platform
Opus 4.7 adds another cost wrinkle: Anthropic says its updated tokenizer may use roughly 1.0–1.35× as many tokens for the same text, and that Opus 4.7 thinks more at higher effort levels, particularly in later turns of agentic settings. Anthropic frames this as improving reliability on hard problems while increasing output tokens, and recommends re-benchmarking end-to-end cost and latency during migration. anthropic.com+2Claude Platform+2
Deployment patterns
The stable deployment pattern is selective escalation. Use ordinary mode for ordinary work, adaptive thinking for complex work, and high or xhigh effort only when quality dominates latency. This matches Anthropic’s own model guidance: Opus 4.7 is positioned for complex reasoning and agentic coding, while effort exists to trade thoroughness against efficiency. Claude API Docs
| Workload | Suggested Claude pattern | Rationale |
|---|---|---|
| Simple Q&A, rewriting, short extraction | No thinking or low effort | Reasoning overhead is mostly waste. |
| Everyday coding edits | Adaptive thinking, medium/high effort depending risk | Some planning helps, but latency still matters. |
| Debugging across files | Adaptive thinking, high effort, visible summarized plan | Multi-step causal search benefits from reasoning and user review. |
| Long-running code agent | Adaptive thinking, xhigh or max, large max_tokens, careful tool permissions |
Opus 4.7’s strongest use case is long-horizon agentic coding. |
| Backend agent with no user-facing reasoning UI | Adaptive thinking plus display: "omitted" |
Preserve reasoning state without streaming summaries. |
| Regulated or high-stakes workflow | Summarized reasoning plus explicit final citations/checks, not raw thought as proof | Thinking may be useful for debugging, but faithfulness is contested. |
The last row is important. Extended thinking should not be treated as an audit log of the model’s true cognition. Anthropic itself says visible thought may be unfaithful and that current model decisions often depend on factors not explicitly discussed in the thought process. For high-stakes workflows, the final answer should cite external evidence, tool outputs, tests, or verifiable artifacts; the thinking trace is at most a debugging aid. anthropic.com
The open question: convergence or Anthropic differentiator?
The market may converge on a hybrid pattern: raw reasoning hidden or access-restricted, summarized reasoning optionally visible, encrypted reasoning state preserved for tool continuity, and effort controls exposed to developers. That is already visible in the partial convergence between Anthropic’s Claude 4.x/Opus 4.7 behavior and OpenAI’s reasoning-model API: both charge for hidden reasoning, both offer summaries, and both preserve encrypted reasoning state across tool-heavy workflows. Claude Platform+2OpenAI Developers+2
But Anthropic’s differentiator may persist at the API-contract level. Claude’s thinking blocks are integrated into the same content-block grammar as text and tool use, and Anthropic’s docs require preserving those blocks during tool calls. That gives harness builders a concrete representation of model reasoning state, even when display is summarized or omitted. OpenAI’s model is closer to hidden internal reasoning tokens plus optional summary/reasoning items. Claude Platform
The unresolved research question is Chain-of-Thought Faithfulness. If visible or summarized reasoning becomes less faithful under training pressure, then transparency becomes less useful for safety and may become misleading to users. If hidden chain-of-thought remains monitorable and legible, OpenAI’s approach has a safety argument. If structured, user-visible reasoning improves debugging, trust calibration, and agent orchestration without destroying monitorability, Anthropic’s approach has a product and research argument. The evidence remains contested: Anthropic warns against over-relying on visible thinking, while OpenAI warns that optimizing or sanitizing chain-of-thought may cause models to hide intent. anthropic.com
The most likely endpoint is not pure transparency or pure opacity. It is layered disclosure: raw reasoning for tightly controlled research or safety monitors, summarized reasoning for users and developers, encrypted reasoning state for continuity, and final answers grounded in verifiable tool outputs. Claude Extended Thinking is important because it made that layering explicit early, forcing the API ecosystem to treat reasoning as an object with semantics rather than an invisible side effect.
Companion entries
Core theory: Test-Time Compute, Chain-of-Thought, Inference-Time Scaling, Self-Consistency Decoding, Chain-of-Thought Faithfulness, Reasoning Models
Anthropic architecture: Claude 3.7 Sonnet, Claude 4, Claude Opus 4.7, Claude Extended Thinking API, Adaptive Thinking, Interleaved Thinking, Thinking Blocks, Claude Code
OpenAI comparison: OpenAI o-Series, Hidden Chain-of-Thought, Reasoning Tokens, Reasoning Summaries, Chain-of-Thought Monitoring
Agent practice: Agent Harness Design, Tool Use, Prompt Caching, MCP, Subagents, Plan Mode, Long-Horizon Coding Agents
Evaluation: GPQA, MATH 500, AIME, SWE-bench Verified, TAU-bench, Terminal-bench
Counterarguments and safety: Reasoning Trace Misuse, Jailbreak Risk, Monitorability Tax, Unfaithful Rationalization, Opaque Reasoning Systems