Folio context folding: 66 of 75, 2.4× lower cost

The fold selects records the runtime already wrote

A harness has to decide what the next model call sees. On a long task that decision is repeated, and each repeat is a bill. The usual implementation asks the model to summarize the transcript. Claude Code's context-window page, read November 13, 2026, says compaction summarizes the conversation history so the session fits. OpenAI's compaction guide, read the same day, says the server returns an encrypted compaction item that carries prior state in fewer tokens, and that the item is opaque. Both are model-produced reductions. Folio's reduction is a view selection over records the runtime wrote on the way.

Three levels, three authors. The model writes only L1, a short note at the end of an ordinary reply: an outcome line and fact lines. The runtime writes L2, a manifest row per call, with the tool, a digest of the arguments, status, size, and, above 1K tokens, a one-line shape. The runtime writes L3, the append-only event log, including the full output when the copy routed to the model was cut. A handle such as t3.12 is the identity. A byte range and a digest are the access hint. A mismatch falls back to parsing the log.

The fold renders into a layout budget. The reference budget is 50K tokens. Twenty percent holds the outline. Of the rest, twenty percent holds the head of the open turn's raw results and the remainder holds the tail. Closed turns start at three resolutions: the newest with call rows, the two before it with the full note, older turns as a brief. Already sent lines are not redrawn at a richer level, which is how the folded prefix stays a cache hit. Recovery is three operations on the same handle. scan reads a bounded page. ctx binds the full text to a file and runs a command the agent writes, so a 900-row table can be counted outside the window. The dossier keeps findings, notes, and rules, and the next fold carries it, under a budget of 12 percent of the window.

The trigger prices the landing point S = B + L + D: stable prefix, layout budget, rendered dossier. A fold is due once the cached reads carried above that landing point have cost as much as rebuilding it. The reference uses DeepSeek-V4-Pro's ratios, 30 for uncached input and cache writes and 90 for output. The extra reasoning after a fold, and the tokens read back, are left out of the trigger on purpose. They show up in later requests, where the cost equation counts them.

66 of 75, and which gaps clear 0.05

The paper's comparisons are internal. Piki-Classic is the same runtime, summarizing at 90 percent of the window. Claude Code, Codex, and SoL-Pi are the authors' runs of those harnesses on DeepSeek-V4-Pro, at a 1 million token window. No cell is copied from a vendor board. The LOCA-bench leaderboard, opened November 13, scores a different protocol, environment growth from 8K to 256K tokens. Folio chains 15 tasks into one session so the history of earlier tasks is still there.

Table 1 is successes out of 75, the mean and standard deviation of successes out of 15 per chain, working time in minutes, and runs the benchmark's contamination scan flagged. Flagged runs stay in the success count.

The comparison the test supports is Folio against Piki-Classic. Paired by task, Folio solves 14 that the summary misses and misses 2 that the summary solves. Exact McNemar p = 0.004. It is faster on 57 of 75 tasks, median time ratio 1.45. Mean time falls from 16.3 minutes to 10.2.

The lead over Claude Code and Codex is a count, and the paper says it is not significant at 0.05. The splits are 14 to 7 (p = 0.19) and 14 to 5 (p = 0.06). SoL-Pi is 20 to 3 (p < 0.001). Codex's 57 includes 27 flagged runs. SoL-Pi's 49 includes 24. Folio's 66 includes 8. A buyer who drops flagged runs cannot recompute the ranking from the printed table, because the paper does not say which flagged runs were successes.

The lead shows up late. Figure 3a is cumulative successes along the 15-task session, and the paper says Folio's gap widens in the second half, after earlier tasks have been folded. Two environments carry a large share of the gap. NHL B2B analysis is 4 of 5 for Folio and 0 of 5 for every other system. A/B-test analysis is 4 of 5 for Folio and at most 2 of 5 for the others.

Where the normalized tokens go

Table 2 is the bill the Piki runtime recorded. Closed harnesses are absent because they did not expose provider usage. Normalized cost is cached input plus 30 times uncached input plus 90 times output, in millions of cached-read equivalents per task.

Over 75 tasks the totals are 1,481 million normalized tokens for Folio and 3,525 million for Piki-Classic. Dividing gives 2.38, which the abstract rounds to 2.4. Folio is cheaper on 68 of 75 tasks and in all 15 environments. The median per-task ratio is 2.29, a bit under the ratio of means, so a few expensive tasks pull the mean.

The tool-call totals are close, 10,701 and 10,173 across the two Piki runs. The paper's point is that the agents do similar work and carry different histories. Piki-Classic waits until the window is about 90 percent full, so a request can carry on the order of 900K tokens. It reads 3.5 times as much input. Its 24 summary requests cost 420 million normalized tokens, 28 percent of Folio's entire bill, before the summary's effect on later requests.

A fold is cheap because it is not a generation. Table 4, medians: 85 folds on the 1M run, zero model calls, 613 milliseconds, context from 242K to 64K, 7.3 times compression of the folded history, dossier 1.2K. Piki-Classic's 24 compactions each call the model, median 101 seconds, from about 908K to 58K. The paper calls 101 seconds 165 times a fold. On the 128K window the median fold is 346 milliseconds, from 121K to 39K. Across 809 folds in the whole section the re-render check, which rebuilds closed turns from the L1 and L2 files and checks that every tool output sits in exactly one manifest row, found one mismatch, in a discarded run.

The 128K row is the practical surprise. It solves 60 tasks, above every 1M baseline in Table 1, at a normalized cost within 0.4 percent of the 1M Folio run. It gets there by folding almost three times as often, reading 32 percent less input, issuing 35 percent more requests, and generating more output. The table prints 0.10 million output tokens against 0.07 million, and the text says 46 percent more, so that percentage is from the unrounded counts. Mean time goes back up to 16.4 minutes. A smaller window, on this price ratio, did not produce a smaller bill. It produced a slower agent that still finished more tasks than the summary baseline.

What the ablations say to keep

Dropping the dossier changes one success, 66 to 65, and 0.1 percent of cost. Dropping the model's turn notes changes three successes, 66 to 63, and lowers cost 1.6 percent. The paper says a different chain of the same configuration already moves success by 3 to 4 out of 15, so those two cuts are not a result you can separate from noise.

The cuts that hurt were run on the first chain only. Removing scan and ctx drops that chain from 13 successes to 8. Three of the seven failures are timeouts or an agent error, and the run had 21 provider retries against none for the full system. Removing the outline as well, so the layout holds only raw text, folds 31 times against 16 and costs 63 percent more, 29.44 million against 18.07 million normalized tokens per task. Success, 11 of 15, sits inside the chain variation. The outline is how a fold stays small without making the next request refill immediately.

The landing-budget sweep, fifth chain, two orders, says the reference 50K is a compromise. From 10K to 70K, folds per chain fall from 49 to 13 and recoveries of folded content fall from 144 to 12. Successes rise from 11 to 13.5 of 15. The two runs at 50K differ by three tasks, 14 and 11. Cost is lowest at 30K, 17.5 million per task. The paper says 50K lies within 11 percent of that minimum. Above 75K the raw area hits a 60K cap, so a configured 150K does not buy a 150K landing, and cost rises with no further success.

On the main 1M run the agent did use the handles: 315 ctx calls, 55 scan calls, 86 expansions, and 21 ctx calls, 6.7 percent, that exited nonzero. In the CanvasArrangeExam case the fold took a 351K context to 83K in 928 milliseconds. The announcements, 793 KB and 16,708 lines across calls t8.6–t8.177, stayed out of the window. ctx returned 6.4K tokens of extracted exam rows. The task passed.

What this means if you ship the harness

Ship the record before you ship a better summarizer. SpecCompact is the right paper if the product already summarizes and the wait is the complaint: an 8.68× median in that paper's Hermes user study, with task scores that do not move as one story. Folio is the right paper if the summary itself is the thing you want off the critical path. The median wait here falls from 101 seconds to 0.6 seconds because the fold makes no model call. The task gain that clears 0.05 is 12 more solved tasks out of 75, inside one runtime, on one model.

Keep a handle that resolves to bytes, and a tool that can compute over the file. A summary that names "the course table" does not let the next step count 16,708 lines. Folio's ctx does, and the ablation that removes it is the one that loses successes on the chain where it was tried. Put the sandbox around that tool before you expose it. The paper does not.

Price the landing point, including the size you intend to keep. Piki-Classic fires at 90 percent of the window, lets the prompt get large, and then pays a rewrite. A reply on the Codex repository, February 2, 2026, described the CLI default then as compaction at 90 percent of the available window. The compaction guide read on November 13 prices a threshold the caller sets, and it does not restate that 90 percent figure. Folio's 1M run fired all 85 folds from the price rule. The 128K run fired 201 of 236 from a safety line, because the cap left little room above the landing point. If the window is the small one, the formula is no longer what folds.

Do not read 66 against 59 as a reason to swap a production Claude Code or Codex install for an unpublished runtime. The paired tests do not say that, the model is DeepSeek-V4-Pro in every row, the cost column does not exist for those products, and Codex's count includes 27 flagged runs. Read it as evidence that the context manager is a large term in cost per task, and that a recoverable fold can beat a summary inside a controlled runtime. HarnessFlow searches the whole harness program and reports cost per task after the search. Evolver stores procedures for a later session. Folio stores this session's tool results. The short-context report asks whether a written handoff can hold accuracy. Folio asks whether the original bytes can stay addressable after the window shrinks. Those are four different changes.

The June 2026 Copilot trace in the Microsoft Research preprint is the scale check. Compaction in 7.8 percent of sessions, 44.2 percent of tokens. Folio does not measure Copilot, and that preprint's PDF was last modified October 20, 2026, so it is background, not a result from this week. If your own traces have the same shape, the sessions worth instrumenting are the long ones, and the number to log is the summary call's latency and the cache miss on the next request. Folio's claim is that both can go to a runtime selection, provided the source was recorded on the way.