Paper breakdown: SpecCompact — faster agent context compaction inside the harness

How it compares with methods in use today

The paper's comparisons are internal. Full History keeps the transcript. Hermes and OpenClaw are the authors' structured-summary baselines, sharing a 2,048-token summary budget with SpecCompact. Target-self, used on the long-document benchmarks, is the target model writing each slot itself, with no drafter and no semantic check. This section puts those tables next to the OpenClaw and Hermes compaction practice that was public on November 5, 2026. No latency number below is taken from a live product dashboard.

OpenClaw and Hermes as agent frameworks compact today

OpenClaw's compaction page, read November 5, 2026, says a conversation that nears the context window has its older turns summarized, the summary is saved in the session transcript, and recent messages stay intact. The full history remains on disk. Built-in compaction summarizes the older history in one model request. A split turn adds a request for the turn prefix, and a failed safeguard quality audit adds one request per corrective attempt. Each request's conversation input is capped at 160,000 characters, which the page calls about 40,000 tokens, or less when the summarizer's own window is smaller. Auto-compaction is on by default. New configs default the mode to safeguard. Manual client-side compaction keeps a recent tail, with keepRecentTokens defaulting to 20,000. That 20,000 is the tail left verbatim. It is not the length of the summary, and it is not the 2,048-token budget in the paper.

The six names in the paper are still the harness format. On November 5, 2026, OpenClaw main (29142856) builds the checkpoint in summary-checkpoint-prompt.ts as one block: Goal, Constraints & Preferences, Progress with Done, In Progress, and Blocked, Key Decisions, Next Steps, and Critical Context. The paper's slot contracts follow that schema, including the instruction to preserve exact file paths, function names, and error messages. The public concepts page describes when compaction runs. It does not print these headings. The headings live in the harness source, and the summarizer still fills them in a single request.

Hermes, the repository the paper cites, is a different template and the same shape of work: one summarizer call. On November 5, 2026, main (be765e31) asks agent/context_compressor.py for a checkpoint with Historical Task Snapshot, Goal, Constraints & Preferences, Completed Actions, Active State, Blocked, Key Decisions, Errors & Fixes, Resolved Questions, Relevant Files, Critical Context, and Unverified / Working Hypotheses, plus a conditional Pruned Skills section. A later compaction updates the previous summary instead of starting from nothing. If the summary call fails, a deterministic fallback fills the same kind of headings from text it can extract locally. The developer guide in that repository says the agent compressor fires at 50% of the context window by default, and a gateway safety pass fires at 85%. Figure 2(a) in the paper draws a shorter Hermes sketch beside OpenClaw. This page uses the November 5 source for the live template, and the paper's tables for the Hermes-style baseline the authors timed.

SpecCompact, in the paper, is a generation method. The experiments compact on a fixed cadence, every eight agent calls, rather than at the 50% or context-window triggers above. What changes is how the summary is written: six drafts, a small model proposing lines, and the target accepting or repairing them.

Latency against Hermes-style and OpenClaw-style summaries

Table 3 in the paper is 20 matched inputs per workload. Speedup is relative to Hermes. SpecCompact uses an additional drafter GPU. Times are seconds.

The abstract's range, 2.04–5.63×, is the six AppWorld and τ³ cells. LongBench sits outside that sentence. On Gemma 4 the agent rows are 4.28–5.63×. On Qwen3.5 they are 2.04–2.41×. OpenClaw-style summarization is already 1.95–2.75× faster than Hermes on the agent rows, and SpecCompact is faster than that OpenClaw baseline in seven of the eight settings. The exception is Qwen3.5 on τ³.

The paper gives three reasons the Qwen3.5 speedups are smaller. Its Hermes baseline is already quicker. The 0.6B drafter matches it less well: draft acceptance is 19.6 percentage points lower than with Gemma 4. And the authors' vLLM setup reuses less of the cached prefix on Qwen3.5, because that model's linear-attention layers also have to restore recurrent state. The paper does not print the acceptance rates themselves, only the 19.6 point gap.

Whether the compacted harness still finishes the task

Table 1 is task performance in percent. Full History does not compact. Bold in the paper marks the best compaction result, which is not copied here. Each cell in the paper also has a 95% confidence interval. The intervals are wide beside the gaps. Gemma 4's AppWorld Normal task-goal scores are 57.74 with interval [47.02, 67.86] for Hermes and 54.76 with interval [44.05, 65.48] for SpecCompact. The point differences below are the ones the paper states, plus the cells it prints.

TGC is task goal completion. SGC is scenario goal completion. Against Hermes, the paper says Gemma 4 loses 2.98 and 4.07 percentage points of TGC on Normal and Challenge, and 2.50 points of τ³ success. Qwen3.5 gains 4.76 and 1.68 TGC points on those splits and 0.83 points of τ³ success, and loses 0.72 points of Challenge SGC. The Qwen Normal SGC cell, which the paper's prose does not highlight, is 21.43 for SpecCompact and 14.29 for both Hermes and OpenClaw.

Read by column, Full History is the highest score everywhere, tied with OpenClaw on Qwen Challenge SGC at 8.63. On Gemma 4, SpecCompact is the lowest compaction score in the table, tied with OpenClaw on τ³ at 47.50. On Qwen3.5 it is the best compaction score on Normal TGC, Normal SGC, and, versus Hermes only, on τ³. OpenClaw is ahead of it on Challenge TGC (17.75 versus 16.07), Challenge SGC (8.63 versus 6.47), and τ³ (65.83 versus 64.58). Faster compaction and a higher task score are not the same result.

AppWorld here is the full Test-Normal and Test-Challenge sets. τ³ is three trials per task on an 80-task subset chosen at random, separately for each target. The paper cites that benchmark as Shi et al., τ-Knowledge, arXiv:2603.04370.

LongBench and RULER

Table 2 is the long-document check. LongBench numbers are ROUGE-L as printed. RULER numbers are the official matching scores, scaled to 100. Execution failures count as zero. Target-self is the control that matters for the method: the same slots, written by the target, with no drafter.

The paper's summary of this table: Qwen3.5 with SpecCompact is within 0.6 points of target-self on both LongBench sets and higher on both RULER lengths. Gemma 4 with SpecCompact is 0.83–4.50 points below target-self across the four settings. The large drop is compaction itself. Full history on RULER scores 90.92 to 92.12. The slot methods score 66.50 to 74.23.

What the system optimizations add on top of parallel slots

Parallel slots alone still repeat the long history and pay for a model call per line. Section 3.3 adds independent scheduling of the six streams, a shared prefix cache, draft buffering of several lines per drafter call, stopping a repair at the next line break, and direct handling of duplicates, over-long lines, markdown headings, and empty-slot markers such as (none). Table 4 is that package, before and after, on 20 matched inputs. Both sides already generate slots concurrently.

The paper states the span as 1.88–2.44× for Gemma 4 and 1.19–1.51× for Qwen3.5. The after times match the SpecCompact agent rows in the latency table. The paper says the table measures the optimizations together, not one component at a time, and that the full task evaluation uses the original implementation and has not been repeated with all of them.

The Hermes user study

The deployment study is separate from Table 3. SpecCompact was integrated into the Hermes codebase and run with Gemma 4 on four RTX PRO 6000 GPUs. Three scenarios came from the authors' own workflows: coding, math, and multitask question answering. Hermes was run ahead of time and paused at a fixed snapshot. People triggered each method from that snapshot and picked which felt faster without being told the method. Compaction time was recorded in the background. Afterward the agent wrote a summary, and a separate blind preference compared the two summaries.

The timed result is a median of 63.74 seconds for the Hermes path and 7.28 seconds for SpecCompact, with a median paired speedup of 8.68×. Dividing 63.74 by 7.28 does not produce 8.68, so the paired figure is its own statistic. The summary votes, 28 responses, were 11 for SpecCompact, 8 for Hermes, 8 similar, and 1 unable to judge. The paper does not print the count for the "which felt faster" question.

A related compaction result, with different models

The November 3 report covered on this site, You don't need long context, also studies compaction as a harness choice. It measures a written handoff on Claude Opus 4.5 and GPT 5.6 Sol, against keeping the full history. Those scores are not a row in the tables above. SpecCompact is about how fast a structured slot summary can be produced, and what that does to AppWorld, τ³, LongBench, and RULER for two open target models. The earlier report is about whether a short live context can hold task accuracy for the closed models it tested. Both treat compaction as harness work. They do not share a baseline.

What the experiments controlled

Names and numbers in this section are printed in the November 4 paper unless a link says otherwise.

Why the slots can be drafted in parallel

The preliminary study uses 100 trajectories from LiveClawBench, six slots each. Monolithic generation writes all six slots in one output. Independent generation writes each slot from the same history and does not see the other slots. An LLM judge scores how well a slot preserves information from the full history. The score is 0 to 5, the sum of five binary checks. The paper does not name the judge model. Independent generation averages 4.73, monolithic generation 4.44. The share of slots scoring at least 4 is 93% and 85%. Reversing slot order, or the order in which independent slots are invoked, moves the mean by at most 0.03. That is the warrant for treating slots as parallel units. It is an adequacy judgment, not an AppWorld score.

The six slots, taken from the OpenClaw schema, are Goal, Constraints and Preferences, Progress, Key Decisions, Next Steps, and Critical Context. The prompt in the paper's appendix tells the drafter it is writing one section of an OpenClaw-style summary, not answering the user. Progress uses Done, In Progress, and Blocked. Empty slots may return (none). Exact file paths, function names, and error messages are supposed to be kept. Each request includes the history and the full schema, and asks for only one slot.

How a line is accepted

The drafter proposes the next line conditioned on the history, the slot instruction, and the lines already accepted in that slot. The target sees the same history and prefix and returns one judgment token. The acceptance score is the estimated probability of a positive judgment divided by the sum of the positive and negative estimates. Variants such as capitalization count, and a missing label is filled from the leftover probability mass by the rule in Section 3.2. The line is accepted at η = 0.7 or higher. Otherwise the target writes a replacement with the rejected line left out of the prompt, and drafting resumes from the new prefix. Verification is one token. Drafting and repair may emit up to 64 new tokens per request. A slot stops at 12 lines or 320 tokens. The assembled summary is held to 2,048 tokens, the same budget as the baselines. A summary past that budget raises an error.

This is semantic checking, in the sense of SpecReason and DREAM-R, which the paper cites. The target can keep a line it would not have worded itself, if the line is supported by the history and consistent with the prefix. It is not token-level speculative decoding, which would require the target's own next tokens.

The drafter

The drafter is Qwen3-0.6B, fine-tuned separately for each target on slot text that the target itself generated. The paper notes that semantic speculation does not require a shared vocabulary, and that they train on text only, so they do not have to store the target's probabilities. One history produces six supervised examples, one per slot. Training and validation examples are separated by trajectory ID. The set is described as about 50K training data from AppWorld, τ³, and LiveClawBench. The paper does not say whether that 50K counts histories or the six-per-history examples.

Each drafter trains for one epoch. LoRA is applied to all linear layers, rank 16, scaling factor 32, dropout 0. The optimizer is AdamW, learning rate 10⁻⁴, cosine decay, warmup ratio 0.05, weight decay 0, gradient clipping at 1.0. The per-device batch size is 2, with 16 gradient-accumulation steps, BF16, a maximum sequence length of 16,384, and random seed 42. Loss is computed only on the slot content.

The agent and long-context protocol

During agent evaluation the harness compacts every eight model calls. System messages, setup messages, and the current input stay. New messages pile up until the next compaction. AppWorld is scored with task goal completion and scenario goal completion on the full Test-Normal and Test-Challenge sets. τ³ is task success, three trials per task, on an 80-task random subset for each target. The paper describes AppWorld as task completion through code and application APIs, and τ³ as task completion through user interaction and tool use.

LongBench uses GovReport and QMSum, reported as ROUGE-L. RULER uses all five task types at 8,000 and 16,000 tokens, with the official matching metrics. Latency and throughput use smaller subsets, 20 matched inputs per workload, rather than the full sets.

Serving for the latency runs is vLLM on NVIDIA RTX PRO 6000 Blackwell GPUs. Gemma 4 runs in BF16 on one GPU. Qwen3.5 runs in FP8 on two GPUs. SpecCompact adds one GPU for the drafter and runs the six slots concurrently. The user-study machine is a different count: Gemma 4 on four of those GPUs, inside Hermes.

What the discussion leaves open

The limitations section says the work is aimed at the speed–accuracy trade-off and the system implementation, and that it does not give a consistent accuracy advantage over target-model summarization. The suggested next step is closer drafter–target alignment, with DREAM-R's reinforcement learning named as an example. The discussion also says slots do not all read the history the same way. Progress and Decisions draw on evidence spread through the context. Goal, Constraints, and Next Steps lean on the beginning or the end. The authors mention slot-conditioned sliding-window attention as a way to speed drafting further, and they leave it undone.

Two related systems in the paper's related-work section attack the wait differently. Slipstream compacts while the agent keeps acting, and uses later steps to check the summary. Parallel Context Compaction summarizes blocks of the input at the same time. SpecCompact's parallelism is across summary slots, with a line-level accept or repair, rather than across time or across input blocks.

Read the paper

The November 4 paper, and the two harnesses it builds on:

• SpecCompact on arXiv
• HTML
• PDF
• Hermes agent
• OpenClaw compaction

Related pages on this site: harnesses, how agents work, task performance, research, You don't need long context, ReAct, harness, and agent.