The Information Machine

Research: Agent Performance Is a Systems Problem, Not a Prompts Problem · history

Version 1

2026-05-24 04:09 UTC · 34 items

What

A systems-centric view of AI agent performance is gaining traction among researchers and engineers: the key claim is that agent behavior emerges primarily from surrounding infrastructure code — the 'harness' — rather than from model choice or prompt quality alone.[1] A concurrent Meta research finding sharpens this: coding agents improve significantly when given concise summaries of prior attempts instead of raw execution logs, suggesting that memory architecture is an underappreciated lever for agent improvement.[2] An arXiv paper on architectural design decisions in AI agent harnesses[3] and a growing body of practitioner writing on 'harness engineering'[12][4][5] are formalizing this view into an emerging sub-discipline.

Why it matters

If agent performance is fundamentally a systems problem, then the dominant industry focus on model benchmarks and prompt tuning misallocates engineering effort. Teams building on top of frontier models may be leaving significant capability on the table by neglecting harness design and memory mechanisms — and the Meta finding suggests this gap is empirically measurable, not just theoretical.[2]

Open questions

  • How large is the actual performance delta attributable to harness design vs. model capability in controlled ablations? The Meta memory-summarization finding implies it is substantial[2], but cross-harness benchmarks are not yet standardized.[13]

  • Is 'harness engineering' becoming a distinct professional role, or will it be absorbed into existing ML engineering and platform engineering tracks? The emergence of resources like Martin Fowler's harness engineering guide[4] and curated lists[6] suggests the former, but the field is still coalescing.

  • What are the failure modes of summarizing past attempts? Summaries compress information; it is unclear when lossy summarization hurts more than raw-log overload helps.[2]

  • Does the systems-centric argument apply equally to non-coding agent tasks (e.g., research, customer support), or is memory reuse of past attempts most valuable specifically in iterative, verifiable domains like code?

Narrative

The central claim circulating in May 2026 is that AI agent performance should be understood as a systems problem — not a model problem, and not a prompts problem. Researcher and commentator Rohan Paul articulated this most directly, summarizing research to argue that 'many AI agents look like 1 model, but their real behavior comes from surrounding code' and that 'agent intelligence is becoming partly a systems problem.'[1] The implication is that engineers who focus exclusively on model selection or prompt engineering are optimizing the wrong variable: the harness — the orchestration logic, tool wiring, memory management, and context construction surrounding the model — is where most emergent capability lives.

A parallel finding from Meta sharpens the memory dimension of this argument. According to Paul's summary, a Meta paper demonstrates that coding agents perform substantially better when given short summaries of prior solution attempts rather than raw execution logs.[2] The insight Paul highlights — 'stronger coding agents do not just need more attempts, but better ways to remember attempts' — cuts against a naive scaling intuition that simply running more iterations will close performance gaps. The bottleneck, the research suggests, is not compute but information architecture: how past experience is encoded, compressed, and made accessible to the model on subsequent attempts.

This conversation is being formalized into something approaching a sub-discipline. An arXiv paper on 'Architectural Design Decisions in AI Agent Harnesses'[3] offers a research-level treatment of the problem. Martin Fowler has published a practitioner-oriented piece on 'harness engineering for coding agent users.'[4] LangChain has published anatomy-of-a-harness documentation.[5] A curated 'awesome-harness-engineering' list has appeared on GitHub.[6] Together, these suggest that the idea is moving from Twitter-level observation toward documented engineering practice. A separate body of work on AI agent memory — including the arXiv paper 'Memory in the Age of AI Agents'[7] and the Mem0 production-agent system[8] — addresses the memory-management component specifically, framing it as a multi-faceted problem that is distinct from simple context management.[9]

The industry context matters here. A piece on Salesforce's potential as a '$50B company hiding inside' the larger firm[10] reflects broader momentum around coding and agentic AI as high-value commercial targets — raising the stakes for whoever gets harness architecture right. Meanwhile, a Hacker News thread on the emotional cost of AI-assisted coding[11] surfaces a human dimension: even if harness engineering improves agent reliability, the developer experience of working with and around AI agents carries its own costs that pure performance metrics do not capture.

Timeline

  • 2026-05-12: Hacker News discussion surfaces emotional and human-factors costs of AI-assisted coding [11]
  • 2026-05-15: Industry analysis frames Salesforce's agentic AI bets as potentially its most valuable business unit [10]
  • 2026-05-18: LangChain's strategic direction on agent harnesses draws practitioner endorsement [15]
  • 2026-05-19: Practitioner commentary notes widespread model benchmarking without equivalent harness or systems evaluation [13]
  • 2026-05-23: Rohan Paul synthesizes research arguing the agent harness is the primary determinant of agent performance, not the model or prompts [1]
  • 2026-05-23: Rohan Paul highlights Meta paper showing coding agents improve substantially when given summarized rather than raw prior-attempt logs [2]

Perspectives

Rohan Paul (@rohanpaul_ai)

Strong advocate for a systems-centric view of agent performance; argues harness design and memory architecture are the primary levers, with model and prompt choices being secondary. Frames this as a counterintuitive finding that should redirect engineering focus.

Evolution: Consistent across both posts; the two tweets are complementary arguments — one systemic (harness), one specific (memory summarization).

Meta Research (via summary)

Empirical: coding agents benefit significantly from summarized past-attempt memory over raw logs. Implicitly supports the memory-architecture-matters argument without making the broader harness-vs-prompts claim.

Evolution: Consistent; this is the initial characterization of their finding as reported in this thread.

Martin Fowler

Practitioner-oriented: harness engineering is a distinct skill set that coding-agent users should develop, separate from prompt engineering or model evaluation.

Evolution: Consistent with his broader orientation toward software engineering discipline; this extends it to the AI agent domain.

LangChain

Infrastructure provider actively defining and promoting the 'agent harness' framing, publishing anatomical documentation to establish vocabulary and architecture patterns.

Evolution: Consistent with LangChain's commercial interest in harness-layer tooling; the direction is endorsed by practitioners in the thread.

Ethan (@DuoEthan)

Critical of the current state of agent evaluation: observes that model benchmarking is ubiquitous while systems-level evaluation is absent, implicitly supporting the idea that the field is measuring the wrong things.

Evolution: Single data point; no evolution to track.

Tensions

  • Prompt-centric vs. systems-centric improvement: The dominant industry practice of tuning prompts and selecting models is implicitly challenged by the claim that the harness is the real determinant of agent behavior.[1] No named voice actively defends the prompt-centric view in this thread, but the tension is structural — much existing tooling and evaluation infrastructure is built around it.[13] [1][13]
  • More attempts vs. better memory: A naive approach to improving coding agents is to run more attempts; the Meta finding argues that the mechanism for retaining and reusing past attempts matters as much as attempt count.[2] This creates a tension between compute-scaling intuitions and information-architecture approaches to agent improvement. [2]
  • Benchmarks measure models, not systems: Existing agent benchmarks (e.g., SWE-bench) are typically reported against model versions, not harness configurations — making it difficult to isolate harness contributions to performance. The practitioner commentary[13] and harness-centric research[3] both imply this is a measurement gap, but no authoritative benchmark framework for harness comparison yet exists. [13][3][1]

Sources

  1. [1] This paper shows that agent performance depends less on prompts alone and more on the harness around them. — Rohan Paul Twitter (2026-05-23)
  2. [2] Meta paper shows that coding agents get much better when they reuse short summaries of past attempts instead of raw logs… — Rohan Paul Twitter (2026-05-23)
  3. [3] Architectural Design Decisions in AI Agent Harnesses - arXiv — reactive:ai-agent-architecture-limits
  4. [4] Harness engineering for coding agent users - Martin Fowler — reactive:agent-performance-architecture
  5. [5] The Anatomy of an Agent Harness - LangChain — reactive:agent-performance-architecture
  6. [6] ai-boost/awesome-harness-engineering - GitHub — reactive:agent-performance-architecture
  7. [7] [2512.13564] Memory in the Age of AI Agents - arXiv — reactive:agent-performance-architecture
  8. [8] [PDF] Mem0: Building Production-Ready AI Agents with - arXiv — reactive:agent-performance-architecture
  9. [9] AI Agents Don't Have a Memory Problem. They Have Three — reactive:agent-performance-architecture
  10. [10] There's a $50B company hiding inside Salesforce — reactive:coding-agent-industry-pivot (2026-05-15)
  11. [11] The Emotional Cost of AI-Assisted Coding — reactive:agent-performance-architecture (2026-05-12)
  12. [12] The Agent Harness Is the Architecture (and Your Model Is Not the ... — reactive:agent-performance-architecture
  13. [13] Everyone is benchmarking models. — reactive:agent-performance-architecture (2026-05-19)
  14. [14] Meta paper reveals improved coding agents through summary reuse — reactive:agent-performance-architecture
  15. [15] @LangChain_OSS @hwchase17 Really strong direction. — reactive:agent-performance-architecture (2026-05-18)