Pith. sign in

REVIEW 1 major objections 6 minor 37 references

Swapping orchestration code cuts agent token cost 41% with quality at parity

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

T0 review · glm-5.2

2026-07-09 23:12 UTC pith:O7GRYBJM

load-bearing objection Solid formal framework and convincing efficiency direction, but the headline magnitude is likely inflated by a naive baseline the 1 major comments →

arxiv 2607.06906 v1 pith:O7GRYBJM submitted 2026-07-08 cs.AI

The Harness Effect: How Orchestration Design Sets the Token Economics of Enterprise Agentic AI

classification cs.AI
keywords harnessorchestrationtasklayermodeltokentokensquality
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

The paper argues that the cost of running AI agents is set not by the model but by the orchestration layer — the software that assembles context, exposes tools, sequences turns, and governs retries. It calls this layer the harness. To isolate its effect, the authors hold 22 tasks and 6 foundation models constant and swap only the orchestration code: a conventional agent loop versus a redesigned harness. The harness cuts blended cost per task by 41%, latency by 44%, and tokens per task by 38%, while task-completion quality stays at parity (0.78 to 0.81). Every model gets cheaper by 33–61%, regardless of vendor or weight class. Quality gains, by contrast, track model capability: stronger models convert harness structure into quality, weaker models sometimes regress on orchestration-heavy tasks. The paper formalizes the token bill as a function of harness-controlled terms — system prompts, replayed history, tool schemas, retrieval payloads, retries — and shows that prompt caching, history compaction, context offloading, and failure-spend governance convert quadratic token growth into approximately linear growth. On this workload, the orchestration layer moved cost per task more than switching between the cheapest and most expensive model did.

Core claim

The cost of an agentic task is governed primarily by the orchestration layer, not by the model. When models, tasks, judges, and price tables are held constant, replacing a conventional agent loop with a redesigned harness reduces tokens per task by 38% and cost per task by 41% across all six models tested, with quality at parity. The effect is model-invariant on efficiency and capability-dependent on quality: the quality gain a model extracts from the harness correlates almost perfectly (r=0.99) with its baseline strength, a relationship the authors call harness leverage.

What carries the argument

The formal decomposition of per-task token spend into harness-controlled terms (system prompt, replayed history, tool schemas, retrieval payloads, user turns, retries) and an effective-input-price model under prompt caching, where the cache hit rate is a function of byte-stability of the prompt prefix across turns — a property set entirely by the orchestration layer. Six mechanism families implement the savings: cache-shape discipline (two-zone prompt with byte-stable prefix), structured compaction (typed checkpoints replacing destructive truncation), context offload (sub-agents as context firewalls, progressive skill disclosure, filesystem spillover), zero-token waiting (durable suspension,

Load-bearing premise

The paper compares exactly one baseline agent loop against one proprietary harness, both from the same vendor. The headline claim that orchestration moves cost more than model choice depends on that specific baseline being representative of conventional agent loops. If the baseline is weaker than typical production systems, the magnitude of the effect is inflated.

What would settle it

Run the same 22 tasks and 6 models under a second, independently developed orchestration layer that implements cache-shape discipline and structured compaction. If that harness does not replicate the 33–61% cost reduction across all models, the effect is specific to the Writer harness rather than a general property of the orchestration layer.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • Organizations evaluating AI agent costs should instrument and optimize the orchestration layer as a first-class economic variable, not just compare per-token prices across model vendors.
  • Agent release gates should track completions-per-million-tokens (CPM) alongside quality, because reporting quality alone incentivizes token maxing — buying marginal quality at worsening token exchange rates.
  • Routing policies should route by feature demand (e.g., sub-agent delegation, multi-step Playbooks) not just prompt difficulty, because orchestration features carry capability floors below which they produce failures rather than function.
  • Harness efficiency gains compound across fleet volume and future model migrations, because the optimization is implemented above the model API and multiplies against every model an organization runs.
  • Multi-agent frameworks that share transcripts across role-prompted agents impose a structural token multiplier (roughly 15× chat-level consumption) that should be metered and justified per task, not assumed free.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • If the harness is the primary cost lever, then the competitive moat in enterprise agentic AI may shift from model ownership to orchestration infrastructure ownership — the layer that sets the price of work and the audit trail for governance simultaneously.
  • The finding that weaker models regress on orchestration-heavy tasks suggests a maturity curve: as harness features proliferate, the minimum viable model capability rises, potentially narrowing the effective model menu for advanced agent deployments.
  • The quadratic-to-linear token growth conversion implies that naive agent loops face a scaling wall — beyond some turn count, cost grows faster than task value — and the harness is the structural fix that delays or removes that wall.
  • If cache hit rate is the single highest-leverage cost variable and it depends on prompt byte-stability, then any orchestration feature that mutates context per turn (dynamic tool selection, adaptive system prompts, real-time retrieval injection) trades caching efficiency for flexibility and should be priced accordingly.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

1 major / 6 minor

Summary. This paper introduces the concept of 'token maxing'—the tendency of agentic AI development to purchase quality with monotonically growing token intensity—and argues that the orchestration layer (the 'harness') is the decisive lever for controlling token economics. The authors formalize per-task token spend at the orchestration layer (Eqs. 1-4), detail six mechanism families (cache-shape discipline, structured compaction, context offload, zero-token waiting, failure-spend governance, model-agnostic floor), and conduct a controlled swap: 22 locked tasks, six foundation models, changing only the orchestration layer (a frozen conventional baseline loop vs. the Writer Agent Harness). They report a 41% cost reduction, 44% latency reduction, and 38% token reduction with quality at parity (0.78 to 0.81, directional at n=22). Efficiency gains are model-invariant (33-61% cost reduction across all six models), while quality gains correlate with baseline model strength (r=0.99, termed 'harness leverage'). The paper also compares six widely used agent systems on token-economic axes (Table 1).

Significance. The paper addresses a timely and practically important problem: the economics of agentic AI systems. The formalization of token economics at the orchestration layer (Section 3), particularly the effective-input-price model under prompt caching (Eq. 4) and the decomposition of input tokens into harness-controlled terms (Eq. 2), is a useful conceptual contribution. The controlled swap methodology (Section 5)—holding models, tasks, judges, and price tables constant while varying only the orchestration layer—is well-designed and isolates the variable of interest. The finding that efficiency gains are model-invariant while quality gains are capability-dependent ('harness leverage') is a novel and actionable empirical observation. The mechanism inventory (Section 4.3) provides a useful taxonomy for practitioners. The paper is candid about limitations (n=22, single-run baseline, single vendor pair), which is commendable.

major comments (1)
  1. Section 6.2 and the abstract headline claim that 'the orchestration layer moved cost per task more than the full spread of the model menu did.' This comparison rests on the baseline loop described in Section 4.2 (monolithic 49KB system prompt replayed every turn, regex-parsed XML tool calls, destructive middle-truncation, no prompt-cache discipline). However, the paper's own Table 1 shows that Claude Code and Claude Cowork already implement 'structural cache policy' and 'compaction contracts.' This means the baseline is missing optimizations that the paper itself documents as present in widely deployed production systems. The 41% cost reduction therefore measures the gap between a naive loop and a sophisticated one, not between a representative conventional loop and the harness. The paper is honest about this in Section 8 ('the magnitudes are specific to this pair'), but the headline 'b'
minor comments (6)
  1. Table 1 (Section 4.4) is described as assessed from 'public documentation and a design-time source study—not head-to-head measurement.' This is clearly stated, but the table's placement alongside measured results from the same paper risks conflating design-level assessment with empirical measurement. Consider adding a visual separator or footnote in the table caption reinforcing this distinction.
  2. Section 6.4: The harness leverage correlation (r=0.99, n=6) is described as 'suggestive rather than conclusive.' This is appropriately hedged, but the abstract states it more strongly ('correlates almost perfectly'). Consider aligning the abstract's tone with the body's caution.
  3. Figure 1 (Section 3.1) is labeled as 'illustrative' and 'schematic.' The measured aggregates appear in Section 6, but the figure itself does not reference those sections. A cross-reference (e.g., 'see Figure 3 for measured aggregates') would help the reader connect the schematic to the data.
  4. Section 4.3(1): The claim that 99.9% of prompt tokens (7,876 of 7,886) were served as cache reads is measured 'on an identical-prefix call in the harness repository.' It is unclear whether this is a representative production call or a best-case scenario. Clarifying the conditions under which this measurement was taken would strengthen the claim.
  5. The term 'token maxing' (Definition 1, Section 3.2) is defined formally, but the definition's condition on declining marginal quality per token requires longitudinal data (a 'development trajectory'). The paper's own data is cross-sectional (two arms at one point in time). The definition is conceptually useful but is not directly tested by the experiment; this could be noted.
  6. Appendix A, Table 6: The 'Mean' row averages across eight capabilities, but the capabilities are heterogeneous (e.g., MSA vs. MCP). A brief note on whether unweighted averaging across heterogeneous capabilities is the intended aggregation would be helpful.

Circularity Check

0 steps flagged

No circularity found: the token-economics formalization is derived from standard API pricing mechanics, and the empirical results are independent measurements, not predictions forced by the model's own definitions.

full rationale

The paper's derivation chain is self-contained and non-circular. The token-economics formalization (Eqs. 1-4) is derived from standard, externally verifiable API pricing mechanics: Eq. (1) is the standard cost formula for a k-turn agent loop; Eq. (2) decomposes input tokens into harness-constructed terms (system prompt, history, tool schemas, retrieval, user turn) — this is an architectural identity, not a fitted relationship; Eq. (3) derives the quadratic growth of naive replay from Eq. (2) by straightforward algebra; and Eq. (4) gives the effective input price under prompt caching using provider-documented discount rates (κ≈0.1, cited to Anthropic platform documentation [32] and Manus context-engineering guidance [30]). None of these equations are fitted to the paper's own experimental data and then presented as predictions. The empirical results (Section 6) are independent measurements: cost, tokens, latency, and quality are recorded per-task by a trace shim, and the cost figures are computed by applying a pinned external price table to recorded token counts (Section 5.4). The 'harness leverage' correlation (r=0.99, n=6) is an empirical observation across six models, not a quantity derived from a model that was fitted to produce it. The definition of 'token maxing' (Definition 1) is a qualitative trajectory characterization, not a quantitative prediction. The paper does cite its own product (Writer Agent Harness) and model (Palmyra X6), but these are objects of evaluation, not theoretical premises that the results assume. The concern that the baseline may be unrepresentative (raised in Section 8 and by the skeptic) is a validity threat about external generalizability, not a circularity in the derivation chain. The central claim — 'the orchestration layer moved cost per task more than the full spread of the model menu did' — is a direct empirical comparison of measured costs, not a result forced by construction.

Axiom & Free-Parameter Ledger

7 free parameters · 4 axioms · 3 invented entities

The free parameters are all design choices in the Writer Harness, not fitted constants. The axioms are mostly standard domain assumptions from cited literature, except the baseline-representativeness axiom which is ad hoc to this paper. The invented entities are conceptual labels for measured phenomena, not postulated physical objects, and each has a falsifiable handle.

free parameters (7)
  • Cache discount multiplier kappa = 0.1
    Stated as approximate provider rate (Section 3.1, Eq. 4); not fitted to the paper's data but drawn from provider documentation [32].
  • Compaction trigger threshold = 80% of input budget
    Design choice for when to trigger structured compaction (Section 4.3, mechanism 2).
  • Live tail message count = 4-12 messages, <=30% of budget
    Design choice for how many recent messages survive compaction verbatim (Section 4.3, mechanism 2).
  • Sub-agent summary cap = 8 KB
    Design choice for context firewall cap on delegated sub-agent returns (Section 4.3, mechanism 3).
  • Loop iteration cap = 50
    Design choice bounding agent loop iterations (Section 4.3, mechanism 5).
  • Tool parallelism cap = 4
    Design choice bounding parallel tool calls (Section 4.3, mechanism 5).
  • Circuit breaker threshold = 3 identical failing calls
    Design choice for when to halt a model re-issuing byte-identical failing tool calls (Section 4.3, mechanism 5).
axioms (4)
  • domain assumption Agent workloads are input-dominated, with input-to-output token ratios near 100:1.
    Stated in Section 3.1, cited to [30]. This makes the input term nearly the whole bill, which is central to the argument that cache hit rate is the highest-leverage cost variable.
  • domain assumption Long, distractor-dense contexts degrade model accuracy.
    Invoked in Section 4.3 and Section 6.6 to argue that token reduction simultaneously cuts cost and improves quality. Cited to [17, 31].
  • domain assumption LLM-as-judge scoring with locked criteria provides reliable quality measurement.
    Section 5.4 relies on LLM-judge panel for headline quality. Judge bias is acknowledged as partially mitigated but not eliminated (Section 8).
  • ad hoc to paper The frozen baseline loop (2026-06-07) is representative of conventional production agent loops.
    The central claim's magnitude depends on this baseline being a fair representative. Section 4.2 describes it as 'the industry default' but it is a single vendor's implementation frozen on one date.
invented entities (3)
  • Token maxing independent evidence
    purpose: Names the pattern of buying quality with monotonically growing token intensity at declining marginal quality per token.
    Definition 1 (Section 3.2) is falsifiable: a development trajectory exhibits token maxing if token intensity grows while marginal quality per token declines. The paper's own data shows the harness moving opposite to this trajectory.
  • Harness leverage independent evidence
    purpose: Names the phenomenon where a model's quality gain from adopting a harness correlates with its baseline strength.
    Measured empirically (r=0.99, n=6) in Section 6.4. Falsifiable with a wider model panel. The paper acknowledges six points is 'suggestive rather than conclusive.'
  • Capability floor independent evidence
    purpose: Names the threshold below which exposing an orchestration feature produces failures rather than function.
    Measured for sub-agent delegation in Table 5: usable only on the two strongest models. Falsifiable by testing more models and features.

pith-pipeline@v1.1.0-glm · 20857 in / 3209 out tokens · 276560 ms · 2026-07-09T23:12:06.029834+00:00 · methodology

0 comments
read the original abstract

Agentic AI development today runs on token maxing: buying capability with tokens -- longer reasoning traces, more turns, wider tool payloads, bigger replayed contexts -- so tokens per task grow faster than task value. Falling per-token prices mask the pattern; total spend rises anyway. We argue the decisive lever against token maxing is the harness: the orchestration layer that assembles context, exposes tools, sequences turns, delegates work, and carries enterprise observability and governance. We isolate it with a controlled swap: 22 locked evaluation tasks, six foundation models (Claude Sonnet 4.6, Gemini 3.1, Gemini Flash 3.5, Qwen 3.6, GLM 5.1, Palmyra X6), changing only the orchestration layer -- a frozen conventional production loop versus the Writer Agent Harness. Holding models constant, the harness cuts blended cost per task 41% ($0.21->$0.12), median wall-clock 44% (48s->27s), and tokens per task 38% (14.2k->8.8k), with task-completion quality at parity (0.78->0.81, directional at this sample size). Efficiency is model-invariant -- every model gets cheaper (33-61%) -- while quality gains are capability-dependent: a model's gain correlates almost perfectly with its baseline strength (r=0.99, n=6), a phenomenon we term harness leverage. Quality per dollar rises 82%; task-completions per million tokens rise from 54.9 to 92.0. On this workload the orchestration layer moved cost per task more than the full spread of the model menu did. We formalize token economics at the orchestration layer (including effective input price under prompt caching), detail the six mechanism families behind the effect -- cache-shape discipline to failure-spend governance -- compare six widely used agent systems on the same axes, and argue the harness is the one component whose efficiency multiplies across every model an organization runs -- present and future.

Figures

Figures reproduced from arXiv: 2607.06906 by Aliaksandra Novik, Anji Boddupally, Artem Yavorskyi, Chris Nickerson, Daniel Rica, Emily DuGranrut, Felix Leung, Garrett Prince, Grace Barnett, Heath Robinson, Hosain Al Ahmad, Jesse Resnick, Juan Carlos Farah, Jyothi Swaroop Meruga, Leonid Kuznetsov, Luke Gorham, Marie Schmoll, Michael Paciullo, Muayad Sayed Ali, Mykyta Osadchyi, Neha Mantri, Nick Westrum, Olivia Benowitz, Parikshith Kulkarni, Radik Chernyshov, Rakshith Vasudev, Rohith Nadimpally, Saumya Das, Sharath Sheripally, Tommy Griscom, Vikas Gangadevi, Waseem Alshikh.

Figure 1
Figure 1. Figure 1: Where token maxing comes from. Illustrative cumulative input tokens for a k-turn agent loop. Full-history replay grows as O(k 2 ) (Eq. 3); harness-managed context—prefix caching, history compaction, offloaded tool outputs— grows as O(k). The shaded gap is spend that buys no quality. Schematic; measured aggregates appear in Section 6. Two further facts sharpen Eq. (1). First, agent workloads are input-domin… view at source ↗
Figure 2
Figure 2. Figure 2: The two-zone prompt. A byte-stable prefix (tool-schema catalog, stable system prompt, append-only transcript) carries up to four provider cache breakpoints [C1–C4]; everything that changes per turn is confined to a volatile tail that is rebuilt each turn and structurally excluded from caching. Measured on an identical-prefix call: 99.9% of prompt tokens (7,876 of 7,886) served as cache reads, pricing the d… view at source ↗
Figure 3
Figure 3. Figure 3: Blended efficiency across six models and 22 tasks. [PITH_FULL_IMAGE:figures/full_fig_p011_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Per-model efficiency under the orchestration swap. [PITH_FULL_IMAGE:figures/full_fig_p012_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Quality parity across 48 capability×model cells. Each point is one capability score for one model, baseline (x) vs. harness (y). Points above the diagonal improved under the harness: 30 improve, 11 are flat (|∆| ≤ 0.02), 7 regress. All regressions belong to the three smaller models, concentrated in orchestration-heavy capabilities (MCP, Playbooks, Presentations). degrades on Gemini 3.1 (0.70) and GLM 5.1 (… view at source ↗
Figure 6
Figure 6. Figure 6: Harness leverage scales with baseline capability. [PITH_FULL_IMAGE:figures/full_fig_p015_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Harness savings at fleet scale. Blended cost per task applied to monthly task volume. At one million agent tasks per month, the harness is worth $90k/month over the baseline ($1.08M/year); the gap widens linearly with volume and multiplies against every model in the mix. 7.3 Escaping token maxing: change the KPI Definition 1 suggests the managerial fix is a measurement fix. Teams that report quality alone … view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

37 extracted references · 37 canonical work pages · 12 internal anchors

  1. [1]

    W. S. Jevons.The Coal Question: An Inquiry Concerning the Progress of the Nation, and the Probable Exhaustion of Our Coal-Mines. Macmillan, 1865

  2. [2]

    Scaling Laws for Neural Language Models

    J. Kaplan, S. McCandlish, T. Henighan, et al. Scaling laws for neural language models.arXiv:2001.08361, 2020

  3. [3]

    Training Compute-Optimal Large Language Models

    J. Hoffmann, S. Borgeaud, A. Mensch, et al. Training compute-optimal large language models.arXiv:2203.15556, 2022

  4. [4]

    J. Wei, X. Wang, D. Schuurmans, et al. Chain-of-thought prompting elicits reasoning in large language models. In NeurIPS, 2022

  5. [5]

    X. Wang, J. Wei, D. Schuurmans, et al. Self-consistency improves chain of thought reasoning in language models. InICLR, 2023

  6. [6]

    S. Yao, J. Zhao, D. Yu, et al. ReAct: Synergizing reasoning and acting in language models. InICLR, 2023. 17

  7. [7]

    Shinn, F

    N. Shinn, F. Cassano, A. Gopinath, K. Narasimhan, and S. Yao. Reflexion: Language agents with verbal reinforcement learning. InNeurIPS, 2023

  8. [8]

    Schick, J

    T. Schick, J. Dwivedi-Yu, R. Dess`ı, et al. Toolformer: Language models can teach themselves to use tools. In NeurIPS, 2023

  9. [9]

    Jiang, Q

    H. Jiang, Q. Wu, C.-Y . Lin, Y . Yang, and L. Qiu. LLMLingua: Compressing prompts for accelerated inference of large language models. InEMNLP, 2023

  10. [10]

    L. Chen, M. Zaharia, and J. Zou. FrugalGPT: How to use large language models while reducing cost and improving performance.arXiv:2305.05176, 2023

  11. [11]

    I. Ong, A. Almahairi, V . Wu, et al. RouteLLM: Learning to route LLMs with preference data.arXiv:2406.18665, 2024

  12. [12]

    T. Han, Z. Wang, C. Fang, S. Zhao, S. Ma, and Z. Chen. Token-budget-aware LLM reasoning. InFindings of ACL, 2025. arXiv:2412.18547

  13. [13]

    S. Xu, W. Xie, L. Zhao, and P. He. Chain of draft: Thinking faster by writing less.arXiv:2502.18600, 2025

  14. [14]

    Leviathan, M

    Y . Leviathan, M. Kalman, and Y . Matias. Fast inference from transformers via speculative decoding. InICML, 2023

  15. [15]

    W. Kwon, Z. Li, S. Zhuang, et al. Efficient memory management for large language model serving with PagedAttention. InSOSP, 2023

  16. [16]

    MemGPT: Towards LLMs as Operating Systems

    C. Packer, S. Wooders, K. Lin, et al. MemGPT: Towards LLMs as operating systems.arXiv:2310.08560, 2023

  17. [17]

    N. F. Liu, K. Lin, J. Hewitt, et al. Lost in the middle: How language models use long contexts.TACL, 2024

  18. [18]

    J. Yang, C. E. Jimenez, A. Wettig, et al. SWE-agent: Agent–computer interfaces enable automated software engineering. InNeurIPS, 2024

  19. [19]

    C. E. Jimenez, J. Yang, A. Wettig, et al. SWE-bench: Can language models resolve real-world GitHub issues? In ICLR, 2024

  20. [20]

    Zheng, W.-L

    L. Zheng, W.-L. Chiang, Y . Sheng, et al. Judging LLM-as-a-judge with MT-Bench and Chatbot Arena. InNeurIPS, 2023

  21. [21]

    Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters

    C. Snell, J. Lee, K. Xu, and A. Kumar. Scaling LLM test-time compute optimally can be more effective than scaling model parameters. InICLR, 2025. arXiv:2408.03314

  22. [22]

    L. A. Agrawal, S. Tan, D. Soylu, et al. GEPA: Reflective prompt evolution can outperform reinforcement learning. InICLR, 2026. arXiv:2507.19457

  23. [23]

    Introducing the Model Context Protocol

    Anthropic. Introducing the Model Context Protocol. Technical note, November 2024.https://www.anthropic. com/news/model-context-protocol

  24. [24]

    Cottier, B

    B. Cottier, B. Snodin, D. Owen, and T. Adamczewski. LLM inference prices have fallen rapidly but unequally across tasks. Epoch AI data insight, 2025. https://epoch.ai/data-insights/ llm-inference-price-trends

  25. [25]

    The Palmyra model family: technical overview

    Writer, Inc. The Palmyra model family: technical overview. Company technical documentation, 2025.https: //writer.com

  26. [26]

    Say hello to Action Agent

    Writer, Inc. Say hello to Action Agent. Engineering blog, 2026. https://writer.com/engineering/ writer-action-agent/

  27. [27]

    S. Gu. From model scaling to system scaling: Scaling the harness in agentic AI.arXiv:2605.26112, 2026. 18

  28. [28]

    Y . Yao, X. Tan, C.-H. Liu, et al. Harness-Bench: Measuring harness effects across models in realistic agent workflows.arXiv:2605.27922, 2026

  29. [29]

    How we built our multi-agent research system

    Anthropic. How we built our multi-agent research system. Engineering blog, June 2025. https://www. anthropic.com/engineering/multi-agent-research-system

  30. [30]

    Y . Ji. Context engineering for AI agents: Lessons from building Manus. Manus blog, 2025.https://manus. im/blog/Context-Engineering-for-AI-Agents-Lessons-from-Building-Manus

  31. [31]

    Hong, et al

    K. Hong, et al. Context rot: How increasing input tokens impacts LLM performance. Chroma Research technical report, 2025.https://www.trychroma.com/research/context-rot

  32. [32]

    Prompt caching

    Anthropic. Prompt caching. Claude platform documentation. https://platform.claude.com/docs/en/ build-with-claude/prompt-caching

  33. [33]

    Q. Wu, G. Bansal, J. Zhang, et al. AutoGen: Enabling next-gen LLM applications via multi-agent conversation. InCOLM, 2024. arXiv:2308.08155

  34. [34]

    LangGraph documentation

    LangChain, Inc. LangGraph documentation. 2026.https://docs.langchain.com

  35. [35]

    CrewAI framework documentation

    CrewAI, Inc. CrewAI framework documentation. 2026.https://docs.crewai.com

  36. [36]

    Hermes Agent

    Nous Research. Hermes Agent. Open-source project and documentation, 2026. https://github.com/ NousResearch/hermes-agent

  37. [37]

    Claude Code and Claude Cowork

    Anthropic. Claude Code and Claude Cowork. Product documentation, 2026.https://docs.claude.com. 19 A Full Capability×Model Matrix Table 6:Capability scores, baseline → harness, model held constant per cell. Codes: MSA = Model & System Awareness; GDR = Grounding & Retrieval; CNG = Content Generation; PLY = Playbooks; MCP = tool use via Model Context Protoco...