Build production AI systems.
With current tools.

budget_tokens (deprecated on 4.6 models): you specify a fixed token budget. Claude used up to that many thinking tokens regardless of complexity. Fine-grained but over-specified — simple queries still consumed budget.

Adaptive thinking (Sonnet 4.6, Opus 4.6+): you set an effort level (low/medium/high/max/xhigh). Claude decides when and how much to think based on query complexity. On simple queries, it may skip thinking entirely. On complex multi-step problems, it thinks extensively. In internal evaluations, adaptive thinking outperforms fixed budget_tokens.

Key addition — interleaved thinking: automatically enabled in adaptive mode. Claude can think between tool calls, not just before the first one. Critical for complex agentic workflows.

Long context windows changed this calculation. For corpora under ~500k tokens that don't change frequently, injecting directly into a 1M context is now viable and often simpler than a RAG pipeline.

• Corpus exceeds 500k–1M tokens — physically can't fit, or cost is prohibitive ($0.15–3 per request at current pricing)
• Knowledge changes frequently — re-injecting a full corpus each request is expensive and wasteful
• Citation grounding required — RAG retrieves traceable sources; long context doesn't
• Latency matters — loading 1M tokens takes time; RAG retrieves relevant subset in milliseconds
• "Needle in a haystack" accuracy — even 1M context has position effects. For precise fact recall in large corpora, retrieval is more reliable than long context
• Multi-user systems — each user has a different relevant subset. RAG is personalised; shared long context isn't

• Transport: HTTP+SSE → Streamable HTTP. More proxy-friendly, used in enterprise environments
• Auth: basic auth → structured OAuth 2.0. Enterprise-grade security built into the protocol
• Tool annotations: tools can now declare read-only, destructive, etc. Claude uses these for safer autonomous decisions
• Structured tool outputs: richer return types, not just strings
• Server-initiated interactions: servers can now prompt users for input mid-execution
• Donated to Linux Foundation (Dec 2025): vendor-neutral governance. Long-term stability guaranteed.

MCP is now the de facto standard — adopted by OpenAI, Google, Microsoft, AWS. 10,000+ public servers, 97M monthly downloads. Any senior AI engineer in 2026 is expected to know MCP deeply, including protocol evolution. Showing you know the spec version history signals you're working with real production systems.

This is the #1 thing interviewers ask about in 2026 — "eval methodology is the new system design." Most candidates can describe building an agent; fewer can describe evaluating one rigorously.

• Task completion rate: did the agent achieve the stated goal? Binary for simple tasks, rubric-scored for complex ones.
• Trajectory efficiency: steps taken / theoretical minimum steps. An agent that achieves a goal in 12 steps when 4 were needed is a problem.
• Tool call correctness: was the right tool called with the right arguments? Log and score each call.
• Loop detection: does it detect when it's stuck? Does it call the same tool repeatedly with the same arguments?
• Graceful degradation: when a tool fails, does it recover or cascade-fail?
• Token efficiency: total tokens used per task completed. Cost per successful completion.

Contextual retrieval (Anthropic, 2024) prepends a short context sentence to each chunk before embedding it. Without this, a chunk like "Revenue increased by 3% year-over-year" has no context when retrieved. With contextual retrieval, it becomes: "This is from the Q3 2024 earnings section of Apple's annual report. Revenue increased by 3% year-over-year."

The embedding of the contextualised chunk is much richer — it captures both the content AND its place in the document. Combined with BM25 hybrid search, Anthropic reported 49% reduction in retrieval failures.

For each chunk, call Claude with: the full document + the chunk + "Please give a short context sentence (max 2 sentences) explaining where this chunk fits in the document." Prepend that to the chunk before embedding. This adds one LLM call per chunk at indexing time, not at query time — a one-time cost.

Both hit 1.0 GA in May 2025. Both are production-ready, both support MCP, RAG, tool calling, chat memory, and 20+ LLM providers. The choice is architectural, not capability-driven.

• Your team is on Spring Boot — seamless autoconfiguration, familiar patterns
• You need Micrometer observability integration out of the box
• You want the Advisors API for standardised RAG and chat patterns

• Running Quarkus, Micronaut, Helidon, or plain Java (not Spring Boot)
• Need GraalVM native image (100ms start, 50MB RAM vs Spring's ~300MB)
• Want more LLM provider coverage (25+ vs Spring AI's 20+)
• Need A2A protocol support or advanced agentic modules

• Don't use long context: 100k docs far exceeds 1M token window. RAG required.
• GraphRAG for legal reasoning: legal documents reference each other (precedents, statutes). Graph traversal retrieves related cases that vector search misses.
• Contextual retrieval + BM25 hybrid: legal docs have precise terminology (exact clause names, statute numbers) that BM25 handles better than semantic alone.
• Permission-aware retrieval: lawyer A cannot see client B's documents. Row-level security in pgvector — filter at retrieval, not after.
• Citation grounding + adaptive thinking: every claim must cite source. Use adaptive thinking with effort: high for complex legal analysis.
• Audit trail: every query + what was retrieved + what was answered. Compliance requirement in legal.
• MCP server for internal APIs: expose document management, matter lookup, billing codes as MCP tools with tool annotations (read-only vs write).

• Step 1 — Profile with Langfuse: find where time actually goes. Often the bottleneck is embedding or retrieval, not the LLM call.
• Step 2 — Parallelise independent work: embed query + check cache + fetch user context simultaneously with CompletableFuture.allOf(). Easy 40–60% reduction.
• Step 3 — Opus 4.8 Fast mode: if you need Opus quality, Fast mode runs at 2.5× speed at $10/$50 per 1M tokens — 3× cheaper than previous Opus Fast.
• Step 4 — Smart model routing: Haiku 4.5 for classification (10× faster than Sonnet), Sonnet 4.6 for generation, Opus only for complex architecture decisions.
• Step 5 — Prompt caching (1-hour TTL): large system prompts cached, TTFT drops significantly.
• Step 6 — Stream everything: p95 wall-clock unchanged but perceived latency drops dramatically.
• Step 7 — Contextual compression: extract only the relevant sentences from retrieved chunks before sending to LLM. Reduces input tokens.

• Evaluation complexity grew: in 2024, RAG eval was novel. In 2026, you're expected to have LLM-as-judge, golden sets, span-level eval, and regression gating in CI. The bar moved.
• Model selection is harder: in 2024 there was one good model. In 2026, Opus 4.8, Sonnet 4.6, Haiku 4.5, Opus 4.8 Fast mode — wrong choice is now expensive, not just suboptimal.
• Context vs RAG decision: 1M token windows created a new architecture choice that didn't exist. You have to evaluate this correctly or you're over-engineering.
• Long-horizon agents are in production: in 2024 agents were demos. In 2026, if your agent fails after 45 minutes of work, that's a production incident. Checkpointing, resumability, cost limits — table stakes now.
• What didn't change: non-determinism is still the hardest thing to test. Prompt brittleness is still real. Hallucinations in high-stakes domains still require the same defence-in-depth.

Extended thinking (older): you set budget_tokens — a hard cap on how many thinking tokens Claude uses. Claude uses up to the budget regardless of whether the problem needs it.

Adaptive thinking (current, Sonnet 4.6 / Opus 4.6+): you set an effort level. Claude decides whether and how much to think. On simple queries it may not think at all. On complex ones it thinks as much as needed. Interleaved thinking (thinking between tool calls) is automatically enabled. Outperforms fixed budget in Anthropic's internal evaluations.

A technique from Anthropic (2024) that prepends a short context sentence to each document chunk before embedding it. "This chunk discusses the cancellation policy from the refund section of the terms of service." The embedding is richer, retrieval is more accurate. Combined with BM25 hybrid search, reported 49% fewer retrieval failures. The contextualisation uses Claude at indexing time — a one-time cost, not per-query.

GraphRAG (Microsoft, 2024) indexes document content as a knowledge graph. Retrieval traverses graph relationships, not just vector similarity. Handles multi-hop questions that vector search misses: "What connected Person A to Event B via Organisation C?" Use for: legal research (connecting related statutes/cases), medical literature (drug interactions, treatment chains), enterprise knowledge (org charts, project dependencies). Neo4j + LangChain4j provides Java implementation. More expensive to build and maintain than vector RAG — use only when multi-hop reasoning is required.

March 2025 (2025-03-26): OAuth 2.0 authorization, Streamable HTTP transport (replaced HTTP+SSE), tool annotations (read-only, destructive), JSON-RPC batching (later removed). June 2025 (2025-06-18): structured tool outputs, enhanced OAuth, server-initiated user interactions, JSON-RPC batching removed. December 2025: donated to Linux Foundation — vendor-neutral permanently. Status June 2026: 97M monthly downloads, 10,000+ servers, adopted by OpenAI, Google, Microsoft, AWS. De facto industry standard.

Both Spring AI 1.1 and LangChain4j 1.x are production-ready as of May 2025. Spring AI 1.1 — best for Spring Boot teams. Autoconfiguration, Micrometer observability, Advisors API, tight Boot integration. LangChain4j 1.x — best for Quarkus/non-Spring teams, GraalVM native image (100ms start, 50MB RAM), more LLM provider coverage (25+), A2A protocol support in 1.x agentic module. For new projects on Spring Boot: Spring AI. For existing Quarkus services or serverless: LangChain4j.

Notepads were deprecated in late 2025 and replaced by Cursor Memories. Notepads required manual creation and maintenance. Memories is a persistent knowledge base that the AI maintains automatically across sessions — it extracts and stores conventions, patterns, and preferences from your conversations without you having to curate them. The result: more up-to-date context with less developer overhead. Team Memories can be shared via deeplinks (Cursor 2.0). Rules (.cursor/rules/*.mdc files) still exist for static, always-on constraints — Memories handles dynamic, evolving project knowledge.