Skip to content
Tekai

Components of A Coding Agent

Sebastian Raschka, PhD April 6, 2026 tutorial high credibility
View source

Referenced in catalog

Claude Code Codex CLI Agent Harness Pattern Agent Memory as Infrastructure Mini Coding Agent

Components of A Coding Agent

Source: Ahead of AI (Substack) | Author: Sebastian Raschka, PhD | Published: 2026-04-04 Category: tutorial | Credibility: high

Executive Summary

  • Raschka argues that a coding agent’s real-world effectiveness is determined by the surrounding system architecture — live repo context, prompt caching, tool validation, context minimization, session memory, and subagent delegation — at least as much as by the underlying model quality.
  • The article uses Claude Code (Anthropic) and Codex CLI (OpenAI) as concrete reference implementations, while the author’s open-source mini-coding-agent (Apache-2.0, Python, Ollama backend) provides a readable educational implementation of all six components.
  • The author makes a strong and contested claim: that an open-weight model (GLM-5 is cited) dropped into a well-engineered harness could match proprietary frontier models like GPT-5.4 in Codex or Claude Opus 4.6 in Claude Code on real coding tasks.

Critical Analysis

Claim: “The surrounding system — tool use, context management, and memory — plays as much of a role as the model itself”

  • Evidence quality: anecdotal
  • Assessment: This framing aligns with a broader industry narrative, most visibly promoted by LangChain (“Anatomy of an Agent Harness”), which has commercial interest in emphasizing the harness layer. Raschka’s own reference implementation (mini-coding-agent) and academic work (arXiv 2603.05344) support the framing from an architectural standpoint. However, independent benchmarks do not cleanly disentangle harness quality from model quality. The Pi Coding Agent authors noted that frontier models need less scaffolding; the harness matters more for mid-tier models. Raschka’s position oversimplifies: the model and harness contributions are not additive but interact — a great harness helps a mediocre model more than it helps a frontier model.
  • Counter-argument: SWE-bench and SWE-bench Verified leaderboards show persistent performance gaps between models on standardized harnesses, suggesting the model layer dominates when the harness is held constant. Claude Sonnet and Opus class models consistently outperform open-weight alternatives even with identical scaffolding. The harness closes some of the gap but does not eliminate it.
  • References:

Claim: “Strategic prompt caching — separating stable prefixes from dynamic turn state — meaningfully reduces cost and latency”

  • Evidence quality: benchmark
  • Assessment: This is well-supported. Anthropic and OpenAI both publish cache pricing (50–75% token cost reduction for cache hits); Anthropic requires explicit cache breakpoints while OpenAI uses automatic caching. The arXiv paper “Don’t Break the Cache” (2601.06007) specifically evaluated prompt caching for long-horizon agentic tasks and confirmed that stable prefix separation is the most effective caching strategy. The claim is technically sound and not vendor-marketing.
  • Counter-argument: Caching benefits only materialize when the stable prefix is long enough (minimum 1,024–4,096 tokens depending on provider) and the cache TTL is respected (5 min default for Anthropic). Short conversations or rapidly changing system prompts negate cache benefits. The practical engineering burden of correctly implementing cache breakpoints is non-trivial, especially in multi-turn agentic sessions where “stable” content may change more often than expected.
  • References:

Claim: “Context minimization — clipping outputs, deduplicating file reads, summarizing old transcript entries — is necessary to sustain long coding sessions”

  • Evidence quality: case-study
  • Assessment: This is practically sound and well-evidenced by production implementations. Claude Code’s compaction system (auto-summary of older turns), OpenCode’s context clipping, and the mini-coding-agent’s deduplication logic all independently converge on the same set of techniques. The LangChain Deep Agents framework documents similar context management as a first-class feature. The problem is real: agentic sessions with 30–50 tool calls routinely hit context limits without active management.
  • Counter-argument: Summarization introduces lossy compression — key details from earlier turns can be lost. Some implementations (Raschka’s mini-coding-agent) use simple clipping by recency, which may discard high-value earlier context that is not semantically recent but still relevant. The right strategy depends on the task; there is no universal approach, and poor summarization can degrade agent performance more than a full context limit would.
  • References:

Claim: “Subagent delegation — spawning bounded child agents for parallel tasks — avoids single-threaded execution bottlenecks”

  • Evidence quality: benchmark
  • Assessment: Supported by evidence from Claude Code’s production implementation. Anthropic reports 90% improvement from multi-agent setups (internal figure, not independently verified). Morph LLM benchmarks show that adding a specialized search subagent to Claude Code lifted SWE-bench Pro score from 55.4% to 57.5% while reducing cost by 15.6% and latency by 28%. Subagent pattern is now standard across Claude Code, Codex CLI, and OpenHands. The context isolation property (each subagent starts with a fresh context window) is well-documented.
  • Counter-argument: Subagent orchestration introduces significant complexity. Each subagent needs a fully specified prompt front-loading all required context, since there is no shared state between parent and child contexts. Poor prompt handoff between parent and subagent is a primary failure mode. For tasks requiring tight coordination (e.g., refactoring multiple interdependent files), parallel subagents can produce conflicting changes without git worktree isolation. No public benchmark tests multi-agent coordination in isolation from model quality.
  • References:

Claim: “An open-weight model like GLM-5 in a similar harness could likely perform on par with GPT-5.4 in Codex or Claude Opus 4.6 in Claude Code”

  • Evidence quality: anecdotal
  • Assessment: This is the most aggressive claim in the article and the weakest in terms of evidence. Raschka presents it as a plausible hypothesis, not a tested result. OpenCode’s experience is instructive: when the commercial OpenCode Go tier routed to GLM-5 (a Chinese open-weight model), users reported receiving “gibberish” responses and significantly worse code quality than with Claude Sonnet or GPT-4-class models. SWE-bench Verified leaderboards show frontier closed models (Claude 3.7 Sonnet, o3) consistently outperforming open-weight alternatives by 10–20 percentage points on standardized coding tasks. The harness narrows the gap; it does not close it.
  • Counter-argument: The claim conflates capability and accessibility. A well-engineered harness running a state-of-the-art open-weight model (e.g., DeepSeek V3, Qwen 2.5-Coder) can approach — but not match — frontier proprietary models on standard benchmarks, at significantly lower cost. The framing is inspirational but should not be taken as engineering guidance without empirical testing on your specific task distribution.
  • References:

Credibility Assessment

  • Author background: Sebastian Raschka holds a PhD, served as a statistics professor at University of Wisconsin–Madison, was a senior ML engineer at Lightning AI, and has 150,000+ newsletter subscribers for “Ahead of AI.” He authored “Build a Large Language Model From Scratch” (Manning, 2024) and several bestselling ML textbooks. He is an independent practitioner with strong academic and engineering credentials. No vendor affiliation that would bias the analysis; the article promotes his own open-source project (mini-coding-agent) but in an educational, not commercial, framing.
  • Publication bias: Independent Substack newsletter with a paying subscriber base; no vendor sponsorship of this article. Raschka has written criticism of LLM hype in prior issues. The mini-coding-agent is educational open-source, not a product.
  • Verdict: high — Raschka is one of the more technically credible independent ML practitioners writing in this space. The article’s architectural analysis is sound even where individual claims are imprecise. The one contested claim (open-weight models matching frontier models in a good harness) is presented as speculation, not established fact, and Raschka labels it as such.