blueprints / frontier-agent@2026-11

The Frontier Agent

The long-horizon, tool-using agent harness you would build in November 2026

November 2026 edition18 componentsHistory Community proposals

Select a component to read how it works. Numbers mark open community proposals.

OrchestrationContext & memoryModelTools & executionVerification & evalsSafetyData flowOut-of-band

Context & memory

Compaction & context editing

When the window fills, the harness replaces older turns with a model-written summary (compaction) and strips stale tool results and thinking (context editing). In 2026 both moved server-side: Anthropic's compaction and context-management APIs and OpenAI's compaction endpoint let harnesses manage context without writing their own summarizers.

Introduced: 2025 · client-side auto-compaction in coding CLIs; 2026 · server-side compaction APIs
Used by: Claude API (compaction, context editing), Claude Code (/compact, auto-compact), OpenAI Responses API / Codex, Google ADK, Cursor
Proposals: None yet

How it works

Mechanisms

Tool-result clearing, the lightest touch. Anthropic's clear_tool_uses_20250919 replaces the oldest tool results with placeholders once input passes a trigger (default 100,000 tokens) and keeps the last 3 tool uses by default; clear_at_least makes each clear worth its cache break, and exclude_tools protects results such as web search.
Thinking clearing. clear_thinking_20251015 keeps only the last N turns of thinking.
Threshold compaction. With compact_20260112, when input tokens reach the trigger (default 150,000, minimum 50,000) the API writes a summary block and drops what came before it:

"context_management": { "edits": [{
  "type": "compact_20260112",
  "trigger": { "type": "input_tokens", "value": 150000 },
  "pause_after_compaction": false,
  "instructions": null
}]}

On-demand and background compaction (beta, September 2026): the application requests a summary when it chooses, can keep recent turns verbatim, and can compute the summary in the background while work continues.
OpenAI. /responses/compact returns a compacted window containing an opaque, encrypted compaction item; Codex calls it once its auto_compact_limit is exceeded.
Google ADK. Token-threshold compaction that keeps N recent events raw, or sliding-window compaction with overlap.

Design decisions

Keep a recoverable original. Compaction is lossy and irreversible inside the window, so keep the full transcript outside it: the Managed Agents session log, Cursor's chat-history file that the agent can search after summarization, Claude Code's transcript behind "summarize from here".
Re-inject essentials afterwards: the plan or task list, invoked skills (Claude Code re-attaches up to 5,000 tokens per skill within a 25,000-token budget), and recently edited files.
Pair with memory. As clearing approaches, Claude is warned so it can write important results to memory files first.
Resets versus compaction. Anthropic's harness needed full context resets with structured handoffs for Sonnet 4.5's "context anxiety"; from Opus 4.5 one continuous session with automatic compaction was enough.

Gotchas

Compaction rewrites the prefix, so the next request misses the cache. Give the system prompt its own cache breakpoint so only the summary is rewritten.
Custom instructions replace the default summarization prompt entirely rather than adding to it.
A summary can come back empty or refused; check for the compaction block rather than the stop reason.
Compact-and-retry loops are a known production failure.
Fixed thresholds do not scale with larger context windows on their own; tune per model.

Why the frontier chose it

Even with 1M-token windows, quality and cost degrade as context grows, and multi-hour tasks exceed any window. Compaction is the only technique that keeps one coherent thread of work going indefinitely. Moving it server-side standardized summary quality and made it compose cleanly with caching and preserved reasoning.

Trade-offs

Lossy: details dropped from the summary can derail later steps.
Each compaction is a prompt-cache miss and an extra model call.
Server-side summaries can be opaque (encrypted) and non-portable across providers.
Thresholds interact with model-specific behavior such as context anxiety.

Alternatives

Context reset with handoff artifacts: Start a fresh agent from progress files and git history. A cleaner slate with more orchestration; still the right tool across sessions.
Sliding-window truncation: Drop the oldest turns. Cheap, but loses the task statement and early decisions.
Offload to subagents: Keep heavy exploration out of the main context in the first place; complements compaction rather than replacing it.

Open questions

Can a summary be evaluated for what it dropped before the loss matters?
Should the agent decide when to compact, rather than a fixed token threshold?
How portable can compacted state be across providers when summaries are encrypted?

Have an answer, or a better design? Propose it

Sources

Community proposals

Propose an improvement

Every component

Orchestration

Orchestrator loop (single-threaded agent loop)
A plain while-loop: sample the model, run its tool calls, append results, repeat until it stops calling tools.
Sub-agents with isolated context
Delegate exploration, research and review to child agents with fresh context that return condensed results.
Planning & task tracking
Externalized plans: plan mode up front, task lists updated in the loop, progress files across sessions.
Durable sessions & checkpoints
An append-only session log outside the harness: crashes and pauses resume from the last event.

Context & memory

Context assembly (context engineering)
Build the smallest high-signal context each turn: stable prefix, short project map, just-in-time reads.
Agent Skills (progressive disclosure)
Folders of instructions, scripts and references; only name + description load until the model opens one.
Memory hierarchy (working, notes, consolidated)
Context window as working memory; plain-file notes and searchable transcripts as long-term memory.
Compaction & context editing
Summarize old turns and clear stale tool results near the limit, so one session can run for hours.
Prompt caching & cache-stable context
Agent loops run ~100:1 input to output; a stable, append-only prefix turns most input into cheap cache reads.

Model

Reasoning model with interleaved thinking
A reasoning model that thinks between tool calls, keeps that reasoning across steps, and scales effort.

Tools & execution

Tool calling & action selection
Typed tool calls emitted in parallel, large catalogs loaded on demand, multi-step chains run as code.
Model Context Protocol (MCP) servers
The open standard connecting agents to tools and data; the 2026-07-28 spec made it stateless.
Sandboxed execution environment
Shell and code run inside OS-level or VM isolation, with scoped writes, egress control and no credentials.
Browser & computer use
Pixel-level GUI control via screenshots, zoom, mouse and keyboard; the fallback when no API exists.

Verification & evals

Observe & verify (feedback signals)
Tool results return as observations; tests, browser checks and separate evaluators decide continue vs done.
Tracing, observability & agent evals
Span-level traces of every model and tool call, transcripts you actually read, and evals reporting pass^k.

Safety

Permissions & classifier-gated approvals
Tiered permissions: allowlists for safe actions, a model reviewer for the rest, humans only on escalation.
Prompt-injection defense in depth
Assume injection sometimes succeeds; limit what a hijacked agent can reach, leak or change.