April 2026 open-source LLM releases, graded on the one metric the leaderboards skip: what happens when the context window fills

The shortlist every recap is covering: Alibaba Qwen 3 on April 8 (Apache 2.0, dense and MoE variants, 128K context window), Google Gemma 4 across four variants under Apache 2.0 with 131K context, Mistral Medium 3 on April 9 with open weights, Meta Llama 4 Scout and Maverick with MoE architecture (Scout with a 10M context window, Maverick at 400B total parameters), DeepSeek V3.2 with frontier reasoning at 128K context, Zhipu GLM-5.1 under MIT at 200K context and 754B MoE, and Arcee Trinity as a 400B Apache 2.0 model for enterprise self-hosting. What none of the recaps cover: what happens when that context window fills during a real agent session.

Because context size is a ceiling, not a throughput number. On Fazm every agent turn sends the live macOS accessibility tree as structured text (role, label, value, coordinates per element). One Slack window emits around 11 to 15K tokens of AX rows. A Finder window with a deep nested sidebar can push past 30K. On a 128K-window model like Qwen 3 or Gemma 4, turn eight or nine saturates the context even before you count the system prompt, the tool schemas, and the model's own assistant output. At that point spec-sheet size stops being the interesting number, and what becomes interesting is whether the session can auto-compact and survive.

It means the Claude Agent SDK emits a content_block_start event whose content_block.type is 'compaction', streams compaction_delta text chunks that summarize the earlier turns, and ends the stream with a system message whose subtype is 'compact_boundary' and whose compact_metadata.pre_tokens records how many tokens lived in the old context. Fazm's custom entry point at acp-bridge/src/patched-acp-entry.mjs lines 65 to 73 and 185 to 199 catches both of these classes of event. The unpatched ACP agent silently drops them. Fazm forwards them through acpClient.sessionUpdate so the UI can render 'compacting context…' and the user knows the agent is not hung, it is rebuilding its memory.

acp-bridge/src/patched-acp-entry.mjs at lines 20 and 21 overrides ClaudeAcpAgent.prototype.createSession. Lines 38 to 40 wrap session.query.next so every SDK iterator value passes through the patched forwarder. Line 65 through 73 catches the compact_boundary system subtype. Line 74 through 78 forwards status_change. Line 79 through 97 forwards task_started and task_notification. Line 98 through 125 forwards api_retry with the HTTP status and typed error category. Line 132 through 152 forwards rate_limit_event. Line 156 through 176 forwards tool_progress and tool_use_summary. Line 181 through 200 forwards the compaction stream chunks. Line 211 through 261 patches prompt() to attach cost and usage metadata. None of those events exist in the unpatched SDK's ACP bridge.

It flips the evaluation from 'how big is the context window' to 'how well does the model respect a summarized transcript once the compaction has run'. Qwen 3 in thinking mode handles this cleanly because the thinking budget re-grounds the model on the summary before the next tool call. Gemma 4 is strong on short turn loops but tends to drift after compaction when tool schemas are re-presented. DeepSeek V3.2 handles long, post-compaction sessions well because its training mix over-indexes on multi-turn reasoning. GLM-5.1 has the largest native window (200K) so it compacts less often, which is a different optimization. Llama 4 Scout with 10M context almost never compacts, which looks like an advantage until you realize the session is now paying attention tax on hundreds of dead AX-tree turns.

Yes. ChatProvider.swift line 372 declares @Published var isCompacting and line 374 declares @Published var compactingSessionKey. The onStatusEvent handler at lines 2592 through 2601 flips isCompacting to true when the bridge forwards a status_change with status 'compacting'. AIResponseView.swift line 310 reads state.isCompacting and line 314 renders 'compacting context…' in orange next to a spinner. The user sees the agent pause. They know it is not hung. The session continues without them hitting retry.

No, and that is the point. The patched entry point sits above the model choice. It patches ClaudeAcpAgent, not the underlying LLM client. Swap in Qwen 3 32B through an Ollama proxy, DeepSeek V3.2 through Together or Fireworks, GLM-5.1 through Zhipu's API, Gemma 4 through llama.cpp behind an Anthropic-shape shim, Mistral Medium 3 through the Mistral API: every one of those setups emits the same compact_boundary events when the context fills, because the Claude Agent SDK runs the compaction loop itself. The patched entry point's only job is to stop the bridge from dropping those events on the floor.

Meta Llama 4 Scout at 10 million tokens, dwarfing every other April 2026 release. GLM-5.1 claims 200K tokens. Qwen 3, Gemma 4, DeepSeek V3.2, and Mistral Medium 3 all land around 128K to 131K. Fazm's compaction forwarder applies to all of them because even the 10M window will eventually exceed the model's effective attention span, and in practice the Claude Agent SDK runs compaction well before the raw cap.

Seven classes. Compact_boundary (line 65-73). Status_change (line 74-78). Task_started (line 79-87). Task_notification (line 88-97). Api_retry (line 98-125), which carries the HTTP status code and typed error category so the UI can distinguish a 429 from a 500. Rate_limit_event (line 132-152), which carries status, reset timestamp, type, utilization, and overage info. Tool_progress (line 156-166) and tool_use_summary (line 167-176), which let the UI show which subtask is running and what it summarized. All seven are silently dropped by the stock ACP agent.

Clone the Fazm app (or crack open the signed bundle's Resources/acp-bridge directory) and open acp-bridge/src/patched-acp-entry.mjs. The file is 268 lines. Grep for compact_boundary and you will find the forwarder at line 65. Grep for content_block_start and you will find the compaction stream handler at line 185. In the Swift side, grep the Desktop/Sources tree for isCompacting and you will find ChatProvider.swift:372 and the UI binding in ChatQueryLifecycle.swift lines 180 to 189. The string 'compacting context…' appears exactly once, at AIResponseView.swift:314. Every fact on this page is traceable to a line number in the shipping source tree.

Because most recaps are written against benchmark leaderboards and model cards, not against a shipping agent. MMLU, AIME, HumanEval, BFCL, and SWE-Bench do not test multi-turn context exhaustion. They test a single-prompt answer. A consumer Mac agent is a twenty- to forty-turn loop where the accessibility tree is re-emitted every turn and the session has to survive multiple compaction boundaries. That regime was not in the benchmark the roundups were citing, so it is missing from the pick-the-right-model commentary.