Pith. sign in

REVIEW 1 major objections 6 minor 50 references

Context Compaction Theory

T0 review · 1 major / 6 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Context compaction has exactly the information cost of one-way communication.

desk verdict Clean, correct framing paper: context generation is one-way communication, with a sound selection-vs-generation separation; the randomized-GEN definition needs a public-coin fix, but this deserves refereeing. read the letter →

arxiv 2608.01326 v1 pith:TYZ3ANBF submitted 2026-08-02 cs.DS cs.AI

Hayder Tirmazi , Sam Markelon , Allison Bishop , Michael Mitzenmacher This is my paper · ORCID
classification cs.DScs.AI MSC 68Q1768Q25
keywords contextcompactionone-waycommunicationcomplexityLLMagentswindowsetmembershipBloomfilterselectionversusgenerationinformation-theoreticlowerbounds
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper aims to put context compaction, the lossy step an AI agent takes when its accumulated state exceeds an LLM's context window, on a formal footing. It proves that for any set of possible future queries, the smallest context that can still answer the queries within a target error is exactly the one-way randomized communication complexity of the query problem: the condenser that summarizes the state plays Alice, the LLM that reads the summary and the query plays Bob, and the summary is the message. This equivalence transfers decades of communication-complexity results into agent design and yields a yardstick for measuring deployed compaction algorithms. The paper also separates two classes of compaction: selecting a subset of the original state is equivalent to a restricted subset-encoding protocol, and there are queries where generation needs a factor of $\Theta(\log n)$ less budget than selection.

What carries the argument

The key object is the induced communication problem $\Pi_G$: Alice receives the item universe $X$, Bob receives the query $q$, Alice sends one message of at most $B$ bits, Bob outputs an answer, and the error is $1 - v_q(\hat{a})$. The equivalence is carried by identifying the condenser $\mathrm{Cond}$, which maps $X$ to a bounded summary, with Alice's encoding, and the interpreter $\mathrm{Int}$, which maps $(\text{summary}, q)$ to an answer, with Bob's decoding. A randomized GEN algorithm is a distribution over pairs $(\mathrm{Cond}_\rho, \mathrm{Int}_\rho)$, which is exactly a public-coin randomized one-way protocol. Corollary 2 specializes the same identification to SELECT, and Theorem 3 uses a bijection argument on the power set to force a $\Theta(\log n)$ separation between selection and generation.

What would settle it

Run the equality-query game twice, once with the summarizer and interpreter sharing random coins and once with independent coins; if the independent-coins budget provably exceeds the shared-coins budget, the paper's public-coin identification fails, because equality has constant public-coin one-way complexity but logarithmic private-coin complexity.

Watch

Extended reading notes

Core claim

The central claim is Theorem 1: for any Context Generation Game $G$ and its induced one-way communication problem $\Pi_G$, the minimum budget at which a randomized GEN algorithm achieves expected error $\le \epsilon$ equals $R^{\to}_{\mu,\epsilon}(\Pi_G)$ in the stochastic regime and $R^{\to}_{\epsilon}(\Pi_G)$ in the oblivious regime. The correspondence is exact because a generation algorithm is literally a condenser--interpreter pair, which is the same pair of functions as Alice's encoding and Bob's decoding in a one-way public-coin protocol. Consequently every one-way lower bound is a context-compaction lower bound, and every one-way protocol is a context-compaction scheme. The paper further proves that selection algorithms correspond to protocols whose messages identify a subset, and exhibits a set of $n$ items and one query where selection needs $n \log_2 n$ bits but generation needs only $n$ bits.

Load-bearing premise

The equivalence assumes that the summarizer and the interpreter share the same random source; if they draw independent randomness instead, the required context size can be larger, and the paper does not flag this distinction.

Editorial extensions

If this is right

  • Known one-way communication lower bounds become unconditional context-compaction lower bounds; for example, set disjointness forces $\Omega(Nm)$ bits for dependency-list queries, no better than storing the dependencies.
  • Approximate answers do not escape the lower bound: a Bloom-filter strategy for set disjointness still needs $\Omega(N \log(|T|/\delta))$ bits, which becomes $\Omega(Nm)$ when the query may name any package in the universe.
  • The minimum budget for generation is computable from communication complexity, giving agent designers a precise target before choosing a compaction method.
  • Selection and generation are separated: for the query in Theorem 3, selection needs $n \log_2 n$ bits while generation needs only $n$ bits, so summary-based compaction can outperform subset-based compaction by a logarithmic factor.
  • The equivalence provides a measurement tool: any deployed summarizer's error can be compared against the optimal budget for the same workload, as demonstrated on set membership queries.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Because the theorem's proof identifies GEN randomness with public coins, agents whose summarizer and interpreter LLM draw independent randomness face the private-coin one-way complexity, which can be strictly larger; equality queries are the standard example.
  • The equivalence is information-theoretic, so achieving an optimal budget may require the interpreter to decode a sketch-like representation; whether an LLM can reliably do that decoding is an open question, and practical gaps may persist even where lower bounds match.
  • Repeated compaction should compound losses: since each invocation runs on the output of an earlier one, the single-shot bound is the most favorable case, and a multi-shot model would likely require error that grows with the number of compactions.
  • An adaptive adversary who sees the summary before choosing the query falls outside Theorem 1; a two-round or adaptive communication model would be the natural replacement, and measuring the gap between oblivious and adaptive compactors could guide real deployments.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

1 major / 6 minor

Summary. The paper introduces two formal games for context compaction in LLM agents: the Context Selection Game and the Context Generation Game. The central result, Theorem 1, states that the minimum budget of a randomized generation algorithm needed to achieve error at most epsilon equals the one-way randomized communication complexity of the induced communication problem, in both the stochastic and oblivious query regimes. The paper then characterizes selection algorithms as subset-encoding one-way protocols (Corollary 2) and proves a Theta(log n) separation between selection and generation on a query that asks for the exact input subset (Theorem 3). It also uses the equivalence to discuss set disjointness lower bounds and presents a case study in which Anthropic's context compaction endpoint answers set membership queries near the random-guess error rate while a same-sized Bloom filter errs on about a third of queries; a no-compaction control attributes the error to compaction.

Significance. If the equivalence holds, it gives a clean dictionary that lets agent designers import one-way communication complexity lower bounds directly as context-budget lower bounds. The proof is short and mostly definitional, but the paper is honest about this; the value is in the framing and in the separation result. Theorem 3 is a genuine, easily checkable separation with a correct injection argument. The case study is a useful template for measuring deployed compaction endpoints against the optimal budget, and it is appropriately hedged: the authors state that the experiment is a snapshot of one endpoint and one workload. The theory has no fitted parameters and makes falsifiable predictions, such as the Bloom-filter comparison curves. The main weakness is an under-specified randomized model in Definition 3, discussed in the major comments.

major comments (1)
  1. [Section 4.1, Definition 3, proof of Theorem 1] Theorem 1 is stated for 'possibly randomized' GEN algorithms, but Definition 3 defines only deterministic condenser-interpreter pairs. The proof treats a randomized GEN algorithm as a distribution over pairs (Cond_rho, Int_rho) indexed by a single random string rho, so Cond and Int share the same coins; this is exactly the public-coin one-way communication model. If the condenser and interpreter instead draw independent randomness, the induced object is a private-coin one-way protocol, and the equality in Theorem 1 can fail in the oblivious regime: for Equality, the public-coin one-way randomized communication complexity is O(1) while the private-coin one-way randomized complexity is Theta(log n). Please add an explicit definition of randomized GEN in Section 3, state that Theorem 1 (in particular Property 2) is for the shared-coin model, and discuss the private-coin variant; the stochastic regime is less affected because averaging over the coins gives a deterministic protocol for the fixed distribution, but the model still needs to be specified.
minor comments (6)
  1. [Section 4.2, Corollary 2] The phrase 'Alice's message identifies a subset S subset of [N]' is ambiguous, because Bob does not receive the universe X and a message containing only indices would not allow Bob to compute a function of the items {x_i : i in S}; please state explicitly that the message encodes the retained items or enough information to reconstruct them, with cost governed by the sum of s(x_i) over the selected items.
  2. [Section 3.3 and Table 1] OpenAI Assistants truncation and LangChain trim_messages preserve message order, while SELECT is defined as an unordered subset whose order cannot convey information; if the model treats order as part of item content, this should be stated, otherwise the classification of order-preserving truncation as SELECT is a modeling simplification that deserves a footnote.
  3. [Appendix A] The calculation of the no-compaction control budget (7280 Kbits) is not explained; please state how this number is derived from the token count of the full context.
  4. [Appendix A, Figure 2] The three measured error rates (0.505, 0.535, 0.555) lie above the random-guess line, so the phrase 'Every run lands on the random guess line' is imprecise; 'near the random-guess line' would be more accurate.
  5. [Theorem 3] The statement 'There is a set Y of n items and a single query q on Y' is slightly confusing because the item universe in each instance is an arbitrary subset X of Y; please clarify that Y is the universe of possible items from which the adversary's universe X is drawn.
  6. [Section 5] The set disjointness example computes the space required by a Bloom-filter-based membership scheme; please label this as an analysis of one natural approach rather than a general lower bound for approximate set disjointness protocols, since the surrounding text could be read as claiming the latter.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: Theorem 1 is a formal equivalence between explicitly modeled formalisms, not a fitted prediction, and no load-bearing self-citation appears.

full rationale

The paper's central claim (Theorem 1) is an equivalence statement, and its proof is an explicit identification of the two formal objects rather than a hidden reuse of the conclusion. Definition 3 defines a GEN algorithm as a condenser-interpreter pair; Definition 4 defines the induced one-way problem Pi_G by letting Alice send Cond(X) and Bob output Int(m,q); the proof then observes that a GEN algorithm G and a one-way communication protocol pi are described by the same pair of functions. This is a legitimate translation between equivalent formalisms, and the paper does not use it to rename a fitted quantity as a prediction. No parameters are fitted to data and then re-predicted: the only empirical component is the Appendix A case study, which measures a deployed endpoint against known Bloom-filter lower bounds and explicitly disclaims generality. Corollary 2 and Theorem 3 are self-contained combinatorial arguments; Theorem 3's lower bound follows from the injectivity of the map X->S(X) on the power set, with no external or self-cited result doing the work. The two self-citations ([1],[40]) appear only as background or as empirical context for learned Bloom filters and multi-agent systems, not as load-bearing justification for any theorem. The only notable caveat is a scoping precision issue, not circularity: Definition 3 does not explicitly define randomized GEN with shared coins, and the proof of Theorem 1 supplies the public-coin model. Private-coin variants can differ, but that is an under-specification in the model section, not a reduction of the theorem to its own inputs. Overall, the derivation chain is self-contained against external benchmarks.

Assumptions & free parameters 0 free parameters · 5 assumptions · 0 invented entities

The framework is self-contained: it defines games and proves an equivalence by exhibiting the same pair of functions. The only external inputs are standard communication complexity definitions and known lower bounds for set membership. No free parameters are fitted. Three domain assumptions shape the model: items as atomic units, computationally unbounded interpreter, and shared randomness for randomized algorithms; all are stated or implicit in the proofs.

assumptions (5)
  • domain assumption Agent context is a set of discrete items with additive sizes; order and formatting carry no information.
    Section 3: context is 'a set of discrete items instead of a sequence of tokens'; selection outputs an unordered subset.
  • domain assumption The interpreter (LLM) is an arbitrary function of the compacted message and query.
    Section 4.3 first caveat: equivalence is information-theoretic and does not guarantee a particular summarizer can compute the optimal budget.
  • domain assumption Randomized generation algorithms use a shared random string for the condenser and interpreter (public coins).
    Proof of Theorem 1: 'indexed by its internal coins ρ'. This is the weakest assumption; private-coin one-way complexity can be larger.
  • standard math Known communication complexity bounds for exact and approximate set membership are valid.
    Carter et al. [14], Bloom [12], Pagh et al. [35]; used for the set membership lower bound and Bloom filter optimality in Appendix A.
  • domain assumption The adversary in the games is stochastic or oblivious; adaptive adversaries are out of scope.
    Section 4.3 second caveat and open problems; the equivalence does not apply to adaptive queries.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Context Compaction Theory." pith.science (2026). https://pith.science/paper/TYZ3ANBF

@misc{pith2026260801326,
  author       = {Pith},
  title        = {Pith review of: Context Compaction Theory},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/TYZ3ANBF}},
  note         = {Machine review of arXiv:2608.01326}
}
read the original abstract

Large Language Models (LLMs) have a bounded context window. The context window is the maximum input size an LLM can consume for a single inference. AI agents rely on a process called context compaction to fit their state within the context window when calling an LLM. Despite its ubiquity, context compaction has received essentially no formal analysis. In this paper, we initiate a formal study of context compaction. We first introduce a framework consisting of two games that capture the two algorithmic strategies for context compaction used by contemporary AI agents in practice. The Context Selection Game models context compaction algorithms that select a subset of an agent's accumulated state to retain. The Context Generation Game models context compaction algorithms that summarize an agent's state by an arbitrary message of bounded length. We then prove an equivalence between the Context Generation Game and one-way communication complexity. The minimum context compaction budget for answering a set of queries within a target error is equal to the one-way communication complexity of the induced communication problem at the same error. Known bounds from communication complexity therefore transfer directly to context compaction. We also show that the Context Selection Game corresponds to a restricted class of one-way communication protocols. Any gap between selection and generation is therefore a gap between two classes of communication protocols. We prove that there exists a set of queries for which generation needs strictly less budget than selection. The equivalence between the Context Generation Game and one-way communication also lets us measure how well a deployed context compaction algorithm performs on a query relative to the optimal strategy. As an example, we present a case study that evaluates Anthropic's context compaction endpoint on set membership queries.

Figures

Figures reproduced from arXiv: 2608.01326 by the authors.

Figure 1
Figure 1. Context compaction in an agent. The agent stores an internal state that grows as it works. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Membership error rate against the context compaction budget for Anthropic’s context [PITH_FULL_IMAGE:figures/full_fig_p018_2.png] view at source ↗

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

50 extracted references · 38 canonical work pages

  1. [1]

    Adversary resilient learned bloom filters

    Ghada Almashaqbeh, Allison Bishop, and Hayder Tirmazi. Adversary resilient learned bloom filters. InInternational Conference on the Theory and Application of Cryptology and Information Security, pages 171–202. Springer, 2025

    work page 2025

  2. [2]

    Aws bedrock

    Amazon Web Services. Aws bedrock. https://aws.amazon.com/bedrock/, 2026. Ac- cessed: 2026-06-23

    work page 2026

  3. [3]

    Claude Code.https://code.claude.com/docs, 2025

    Anthropic. Claude Code.https://code.claude.com/docs, 2025. Accessed: 2026-04-13

    work page 2025

  4. [4]

    Automatic context compaction

    Anthropic. Automatic context compaction. https://platform.claude.com/cookbook/ tool-use-automatic-context-compaction, 2025. Accessed: 2026-04-13. 14

    work page 2025

  5. [5]

    How we built our multi-agent research system

    Anthropic. How we built our multi-agent research system. https://www.anthropic.com/ engineering/multi-agent-research-system, 2025. Accessed: 2026-04-13

    work page 2025

  6. [6]

    Anthropic. Pricing. https://platform.claude.com/docs/en/about-claude/pricing,

    work page

  7. [7]

    Prompt caching

    Anthropic. Prompt caching. https://platform.claude.com/docs/en/ build-with-claude/prompt-caching, 2026. Accessed 2026-07-20

    work page 2026

  8. [8]

    Compaction

    Anthropic. Compaction. https://platform.claude.com/docs/en/ build-with-claude/compaction, 2026

    work page 2026

Show all 50 references
  1. [9]

    Cursor: The AI code editor

    Anysphere. Cursor: The AI code editor. https://cursor.com, 2024. Accessed: 2026-04-13

    2024

  2. [10]

    Claude fable 5: Intelligence, performance and price analysis

    Artificial Analysis. Claude fable 5: Intelligence, performance and price analysis. https: //artificialanalysis.ai/models/claude-fable-5, 2026. Accessed 2026-07-20

    2026

  3. [11]

    Goose: An open-source, extensible ai agent

    Block. Goose: An open-source, extensible ai agent. https://github.com/aaif-goose/ goose, 2025. Accessed: 2026-04-25

    2025

  4. [12]

    Space/time trade-offs in hash coding with allowable errors.Communications of the ACM, 13(7):422–426, 1970

    Burton H Bloom. Space/time trade-offs in hash coding with allowable errors.Communications of the ACM, 13(7):422–426, 1970

    1970

  5. [13]

    Network applications of Bloom filters: A survey

    Andrei Broder and Michael Mitzenmacher. Network applications of Bloom filters: A survey. Internet Mathematics, 1(4):485–509, 2004

    2004

  6. [14]

    Exact and approximate membership testers

    Larry Carter, Robert Floyd, John Gill, George Markowsky, and Mark Wegman. Exact and approximate membership testers. InProceedings of the Tenth Annual ACM Symposium on Theory of Computing (STOC), pages 59–65, 1978

    1978

  7. [15]

    Muthukrishnan

    Graham Cormode and S. Muthukrishnan. An improved data stream summary: the count-min sketch and its applications.Journal of Algorithms, 55(1):58–75, 2005

    2005

  8. [16]

    Adaptive learned bloom filter (ada-bf): Efficient utilization of the classifier with application to real-time information filtering on the web

    Zhenwei Dai and Anshumali Shrivastava. Adaptive learned bloom filter (ada-bf): Efficient utilization of the classifier with application to real-time information filtering on the web. In Advances in Neural Information Processing Systems (NeurIPS), 2020

    2020

  9. [17]

    React agent.https://www.ibm.com/think/topics/react-agent, 2026

    Dave Bergmann. React agent.https://www.ibm.com/think/topics/react-agent, 2026

    2026

  10. [18]

    Aider: AI pair programming in your terminal

    Paul Gauthier. Aider: AI pair programming in your terminal. https://aider.chat/docs/ repomap.html, 2026. Accessed: 2026-04-26

    2026

  11. [19]

    Gemini CLI

    Google. Gemini CLI. https://github.com/google-gemini/gemini-cli , 2025. Ac- cessed: 2026-04-13

    2025

  12. [20]

    Hallucination is a consequence of space-optimality: A rate-distortion theorem for membership testing.arXiv preprint arXiv:2602.00906, 2026

    Anxin Guo and Jingwei Li. Hallucination is a consequence of space-optimality: A rate-distortion theorem for membership testing.arXiv preprint arXiv:2602.00906, 2026

    2026 arXiv

  13. [21]

    On the brittleness of LLMs: A journey around set membership.arXiv preprint arXiv:2511.12728, 2025

    Lea Hergert, Gábor Berend, Mario Szegedy, György Turán, and Márk Jelasity. On the brittleness of LLMs: A journey around set membership.arXiv preprint arXiv:2511.12728, 2025

    2025

  14. [22]

    LLMLingua: Com- pressing prompts for accelerated inference of large language models

    Huiqiang Jiang, Qianhui Wu, Chin-Yew Lin, Yuqing Yang, and Lili Qiu. LLMLingua: Com- pressing prompts for accelerated inference of large language models. InProceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, 2023

    2023

  15. [23]

    LLMLingua-2: Data distillation for efficient and faithful task-agnostic prompt compression

    Huiqiang Jiang, Qianhui Wu, et al. LLMLingua-2: Data distillation for efficient and faithful task-agnostic prompt compression. InFindings of the Association for Computational Linguistics: ACL 2024, pages 963–981, 2024

    2024

  16. [24]

    Acon: Optimizing context compression for long-horizon llm agents.arXiv preprint arXiv:2510.00615, 2025

    Minki Kang, Wei-Ning Chen, Dongge Han, Huseyin A Inan, Lukas Wutschitz, Yanzhi Chen, Robert Sim, and Saravan Rajmohan. Acon: Optimizing context compression for long-horizon llm agents.arXiv preprint arXiv:2510.00615, 2025

    2025 arXiv

  17. [25]

    The case for learned index structures

    Tim Kraska, Alex Beutel, Ed H Chi, Jeffrey Dean, and Neoklis Polyzotis. The case for learned index structures. InProceedings of the 2018 International Conference on Management of Data, pages 489–504, 2018. 15

    2018

  18. [26]

    Cambridge University Press, 1997

    Eyal Kushilevitz and Noam Nisan.Communication Complexity. Cambridge University Press, 1997

    1997

  19. [27]

    Trim messages

    LangChain. Trim messages. https://reference.langchain.com/python/ langchain-core/messages/utils/trim_messages, 2024. Accessed: 2026-04-26

    2024

  20. [28]

    Langgraph.https://www.langchain.com/langgraph, 2026

    LangChain. Langgraph.https://www.langchain.com/langgraph, 2026

    2026

  21. [29]

    Compressing context to enhance inference efficiency of large language models

    Yucheng Li, Bo Dong, Frank Guerin, and Chenghua Lin. Compressing context to enhance inference efficiency of large language models. InConference on Empirical Methods in Natural Language Processing (EMNLP), 2023

    2023

  22. [30]

    Latent context compilation: Distilling long context into compact portable memory.arXiv preprint arXiv:2602.21221, 2026

    Zeju Li, Yizhou Zhou, and Qiang Xu. Latent context compilation: Distilling long context into compact portable memory.arXiv preprint arXiv:2602.21221, 2026

    2026

  23. [31]

    Lost in the middle: How language models use long contexts.Transactions of the Association for Computational Linguistics, 12:157–173, 2024

    Nelson F Liu, Kevin Lin, John Hewitt, Ashwin Paranjape, Michele Bevilacqua, Fabio Petroni, and Percy Liang. Lost in the middle: How language models use long contexts.Transactions of the Association for Computational Linguistics, 12:157–173, 2024

    2024

  24. [32]

    A model for learned Bloom filters and optimizing by sandwiching

    Michael Mitzenmacher. A model for learned Bloom filters and optimizing by sandwiching. In Advances in Neural Information Processing Systems, volume 31, 2018

    2018

  25. [33]

    Assistants API: Truncation strategy

    OpenAI. Assistants API: Truncation strategy. https://developers.openai.com/api/ docs/assistants/deep-dive, 2024. Accessed: 2026-04-26

    2024

  26. [34]

    Codex CLI: Lightweight coding agent that runs in your terminal

    OpenAI. Codex CLI: Lightweight coding agent that runs in your terminal. https://github. com/openai/codex, 2025. Accessed: 2026-04-25

    2025

  27. [35]

    How to approximate a set without knowing its size in advance

    Rasmus Pagh, Gil Segev, and Udi Wieder. How to approximate a set without knowing its size in advance. InProceedings of the 54th Annual IEEE Symposium on Foundations of Computer Science (FOCS), pages 80–89, 2013

    2013

  28. [36]

    Meta-learning neural bloom filters

    Jack W Rae, Sergey Bartunov, and Timothy P Lillicrap. Meta-learning neural bloom filters. In Proceedings of the 36th International Conference on Machine Learning (ICML), 2019

    2019

  29. [37]

    Communication complexity (for algorithm designers).Foundations and Trends in Theoretical Computer Science, 11(3-4):217–404, 2016

    Tim Roughgarden. Communication complexity (for algorithm designers).Foundations and Trends in Theoretical Computer Science, 11(3-4):217–404, 2016

    2016

  30. [38]

    Fast partitioned learned bloom filter

    Atsuki Sato and Yusuke Matsui. Fast partitioned learned bloom filter. InInternational Confer- ence on Neural Information Processing Systems (NeurIPS), 2023

    2023

  31. [39]

    Agent laboratory: Using llm agents as research assistants.Findings of the Association for Computational Linguistics: EMNLP 2025, pages 5977–6043, 2025

    Samuel Schmidgall, Yusheng Su, Ze Wang, Ximeng Sun, Jialian Wu, Xiaodong Yu, Jiang Liu, Michael Moor, Zicheng Liu, and Emad Barsoum. Agent laboratory: Using llm agents as research assistants.Findings of the Association for Computational Linguistics: EMNLP 2025, pages 5977–6043, 2025

    2025

  32. [40]

    Orla: A library for serving llm-based multi-agent systems, 2026

    Rana Shahout, Hayder Tirmazi, Minlan Yu, and Michael Mitzenmacher. Orla: A library for serving llm-based multi-agent systems, 2026. URL https://arxiv.org/abs/2603.13605

    2026

  33. [41]

    Malicious URLs dataset

    Manu Siddhartha. Malicious URLs dataset. https://www.kaggle.com/datasets/ sid321axn/malicious-urls-dataset, 2021

    2021

  34. [42]

    OpenCode: The open source ai coding agent

    SST. OpenCode: The open source ai coding agent. https://github.com/sst/opencode,

  35. [43]

    Minions: Stripe’s one-shot, end-to-end coding agents

    Stripe. Minions: Stripe’s one-shot, end-to-end coding agents. https://stripe.dev/blog/ minions-stripes-one-shot-end-to-end-coding-agents , 2026. Accessed: 2026-04- 13

    2026

  36. [44]

    Partitioned learned bloom filters

    Kapil Vaidya, Eric Knorr, Michael Mitzenmacher, and Tim Kraska. Partitioned learned bloom filters. InInternational Conference on Learning Representations, 2021

    2021

  37. [45]

    Efficient streaming language models with attention sinks

    Guangxuan Xiao, Yuandong Tian, Beidi Chen, Song Han, and Mike Lewis. Efficient streaming language models with attention sinks. InInternational Conference on Learning Representations (ICLR), 2024. 16

    2024

  38. [46]

    React: Synergizing reasoning and acting in language models

    Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. InInternational Conference on Learning Representations (ICLR), 2023

    2023

  39. [47]

    Recursive language models.arXiv preprint arXiv:2512.24601, 2025

    Alex L Zhang, Tim Kraska, and Omar Khattab. Recursive language models.arXiv preprint arXiv:2512.24601, 2025

    2025 arXiv

  40. [48]

    H2O: Heavy-hitter oracle for efficient generative inference of large language models

    Zhenyu Zhang, Ying Sheng, Tianyi Zhou, Tianlong Chen, Lianmin Zheng, Ruisi Cai, Zhao Song, Yuandong Tian, Christopher Ré, Clark Barrett, Zhangyang Wang, and Beidi Chen. H2O: Heavy-hitter oracle for efficient generative inference of large language models. InAdvances in Neural I...

    2023

  41. [49]

    looks like

    Dawei Zhu, Rui Meng, Yale Song, Xiyu Wei, Sujian Li, Tomas Pfister, and Jinsung Yoon. Pa- perbanana: Automating academic illustration for ai scientists.arXiv preprint arXiv:2601.23265, 2026. A Context Compaction in the Wild We test how close a deployed context compaction endpo...

    2026

  42. [2026]

    Accessed: 2026-04-25

    2026

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.