Latest LLM news, April 2026: the compaction events every roundup misses

It is the system message the Claude ACP SDK emits when the agent rewrites its conversation history to stay under the context window. The message includes compact_metadata.trigger (for example 'auto' when the session approaches the limit, or 'manual' when code forced it) and compact_metadata.pre_tokens (the token count immediately before compaction ran). The vanilla @agentclientprotocol/claude-agent-acp package drops this message before it reaches the parent process. Fazm patches the SDK at acp-bridge/src/patched-acp-entry.mjs lines 65-71 to forward it, so the Mac app can tell the user 'your context hit X tokens, Claude rewrote it' instead of letting the rewrite happen invisibly.

acp-bridge/src/patched-acp-entry.mjs. The file reaches into the ACP SDK and replaces ClaudeAcpAgent.prototype.prompt (line 212 in the patched file) and wraps the SDK's internal message iterator (lines 38-204). Inside the wrapper it calls acpClient.sessionUpdate with a new update kind 'compact_boundary' whenever it sees subtype === 'compact_boundary' on a system message. That update then travels over JSON-RPC to the parent Node process, out to Swift as a JSON line, and into the UI as a StatusEvent.compactBoundary(trigger, preTokens) Swift enum case.

Three more. status (subtype === 'status' becomes a status_change update), task_started (subtype === 'task_started' becomes a task_started update with taskId + description), and api_retry (subtype === 'api_retry' becomes an api_retry update with httpStatus, errorType, attempt, maxRetries, retryDelayMs). It also forwards rate_limit_event at line 132 with eight fields including utilization, overageStatus, isUsingOverage, and surpassedThreshold. All of these are dropped by the vanilla SDK and all surface as typed Swift enum cases.

Both. The same patch watches for stream_event messages where the delta is a compaction_delta (patched-acp-entry.mjs lines 191-200). Each delta fires an acpClient.sessionUpdate with kind 'compaction_delta' carrying the incremental text. Upstream in index.ts at lines 2391-2400 the bridge converts 'compaction_start' into a status_change 'compacting' for the UI and intentionally suppresses the compaction_delta text back to Swift because it is too high frequency. The UI shows 'compacting' state via status_change, the eventual compact_boundary fires with the final token count, and the low-level text stream stays available in logs if debugging is needed.

Because most consumers of @agentclientprotocol/claude-agent-acp do not render a UI that benefits from them. The vanilla agent is designed to let the SDK own the conversation loop and only surface user-visible tokens through sessionUpdate kinds the protocol spec already knows about (agent_message_chunk, tool_call, etc). Compaction metadata, task start signals, and rate-limit telemetry do not map to those kinds. For a shipping Mac app these are exactly the signals you want, which is why Fazm opens the SDK and adds custom sessionUpdate kinds for each one.

case compactBoundary(trigger: String, preTokens: Int). It lives at /Users/matthewdi/fazm/Desktop/Sources/Chat/ACPBridge.swift lines 138-154, inside a public StatusEvent enum that also carries cases for compacting(Bool), taskStarted, taskNotification, toolProgress, toolUseSummary, and rateLimit. The InboundMessage decoder at lines 1082-1085 turns the JSON line {type: 'compact_boundary', trigger, preTokens} into .compactBoundary(trigger: trigger, preTokens: preTokens), and lines 856-857 route it out through onStatusEvent. That is the whole pipeline: dropped SDK message to typed Swift event in about four files.

Those numbers live in the press release. Compaction is the runtime answer to what happens when a long session gets near the top of any of those windows. Even Llama 4 Scout's 10 million token context, the April 2026 headline, still matters less to a live agent than the rewrite strategy kicking in when a session fills up. The observable boundary event is how a shipping app tells the user 'you just crossed a memory boundary' instead of silently pretending the conversation never changed.

No. Anthropic's context management API, introduced earlier in 2026, is a server-side feature that controls how long-context prompts are packed and how cache breakpoints are inserted. compact_boundary is an SDK-level event emitted when the ACP agent itself triggers a compaction during a running session. Both can be active at once. Fazm cares about the SDK event because that is what arrives in the subprocess and needs to surface to the user.

They depend on the Claude tier. For Sonnet and Opus sessions in Fazm we see compactions triggering around the high 150,000s when the SDK's auto heuristic decides the next turn might bust the window. For Haiku the compaction activity on shorter windows triggers a little lower. The exact trigger heuristic lives inside the ACP SDK, which is one reason Fazm forwards both trigger and pre_tokens instead of computing them in the bridge, the SDK is the ground truth.

Two places. While compaction is running, the Fazm floating control bar shows a 'compacting' status, driven by the status_change: 'compacting' update that index.ts line 2392 emits when it sees compaction_start. When compaction finishes, the compact_boundary event lands with the final trigger and pre_tokens numbers, which the Swift side can log or surface (current build uses it for diagnostics and for picking smarter compaction prompts on repeated triggers in the same session).

Yes and no. Anthropic's prompt cache is keyed on stable prefixes. After a compact_boundary, the conversation history has been rewritten, which means any cache breakpoints that used to match the prefix no longer do. Fazm accounts for this by tracking cacheReadTokens and cacheWriteTokens separately on each turn (acp-bridge/src/index.ts around line 1783), so an operator can see the cache-write spike on the first turn after compaction. This is useful for diagnosing 'why is my first message after a long chat so expensive' kinds of questions.

Yes. Even without Fazm, the pattern is worth copying. Spawn the Claude ACP SDK as a subprocess, but also run your own message iterator that sniffs for compact_boundary, compaction_start, and rate_limit_event at the raw SDK level. If you do not, those signals stay hidden inside the SDK loop and your top-level app only sees post-compaction state. The Fazm patch at patched-acp-entry.mjs is a small enough reference implementation to read through in ten minutes.