AI Engineering for Agentic Systems

Garry Tan's framework crystallizes a debate that has been simmering across agent engineering: where should intelligence actually live? In Tan's formulation, the harness — the program that runs the LLM — does only four things: runs the model in a loop, reads and writes files, manages context, and enforces safety. Everything else is pushed up into markdown 'skills' (fuzzy human judgment expressed as prompts and playbooks) or down into deterministic code. The provocation is sharp: 'The secret sauce isn't the model. It's the thing wrapping the model: the harness' — and that thing should be deliberately small.

The framework's appeal is partly architectural and partly economic. A fat harness with bespoke orchestration logic gets out of date the moment the underlying model improves; thin harnesses ride the model curve. The Hex engineering team's experience reinforces this from another angle — Izzy Miller noted that harness decisions, not model selection, dominate architecture quality, and Hex's production system carries roughly 100K tokens of tool definitions, suggesting the real surface area is in how skills and tools are designed, not in the runtime.

The most circulated piece of agent-skeptic math this month came from a Reddit comment on a 10-agent Obsidian system: 'Chain 10 steps at 90% accuracy each and your overall pipeline success rate is ~35%.' That single line explains why 86-89% of enterprise agent pilots fail before reaching production and why Shopify's Andrew McNamara explicitly tells teams to 'avoid multi-agent architectures early.'

The data backs the skepticism: only 95 of 1,837 surveyed teams (~5%) report agents live in production, and 70% of regulated enterprises rebuild their stack every three months or faster. The most-skipped engineering piece, according to practitioners who have shipped agents to 20+ startups, is observability and decision-trace logging — agentic workflows fail silently with 'plausible-but-wrong actions' that pass shallow eval but corrupt downstream state. Bri Kopecki's 7-skill framing on IBM Technology lands the same point from a curriculum angle: reliability, evaluation, and security are listed as first-class disciplines alongside system design and retrieval, not as afterthoughts.

For most of 2024-2025, agent builders treated frontier models as general-purpose engines and bolted on tool-calling via prompting and fine-tuning. Ant Group's Ling-2.6 family inverts that. Ling-2.6-flash is a 104B-parameter Mixture-of-Experts with only 7.4B active per token, and crucially it was post-trained with Agentic RL specifically for tool calling and multi-step planning — described by analysts as 'sharpened for AI agent scenarios.' The trillion-parameter Ling-1T sibling already hits ~70% tool-call accuracy on the BFCL V3 benchmark with only light instruction tuning.

The economic story is the intelligence-to-token ratio: agentic workloads burn through context and tool calls aggressively, and a sparse MoE optimized for that pattern costs less to run at scale than a dense generalist. Combined with the 'thin harness' philosophy, this suggests an architectural convergence — a small, fast harness orchestrating skills against a model that was itself trained to be the agent, rather than coaxed into being one.

Amid the louder debates about frameworks and multi-agent orchestration, the Model Context Protocol has done something rare in AI infrastructure: it became a de facto standard without an obvious fight. Anthropic shipped MCP in late November 2024 as a way to standardize how LLMs talk to tools — guidebooks now describe it as 'USB-C for AI.' By February 2026 the protocol had reached 97 million monthly SDK downloads and over 10,000 active public MCP servers.

Google's A2A protocol followed in April 2025, and the Linux Foundation's Agentic AI Foundation arrived in late 2025 to formalize the standards layer. The practical implication for AI engineers is that the 'tool integration' skill on Kopecki's 7-skill list is increasingly a configuration problem rather than a bespoke integration problem — you wire your agent to a registry of MCP servers rather than writing one-off adapters. That, more than any single framework release, is what makes the agent stack feel finally portable.

The numbers tell two stories at once. Gartner projects 40% of enterprise applications will embed AI agents by end of 2026, up from less than 5% in 2025 — an 8x jump that anchors most vendor decks. Cleanlab's production survey paints the opposite picture: ~5% of teams have agents live, 70% of regulated enterprises rebuild their stack every quarter, and 'only five percent of the five percent of companies with agents in production even worry about accurate tool calling.' k4i.com's tracking of pilots puts the failure rate at 86-89%.

The split isn't necessarily contradictory — Gartner is measuring application-level embedding (often shallow copilots), while Cleanlab and k4i are measuring genuine autonomous-loop deployments. Reddit's reception of a 424-page 'Agentic Design Patterns' PDF from a senior Google engineer captured the mood: half the comments called it a well-structured introduction; the other half called it AI slop rehashing known concepts. That bimodal reception is the cluster's tell — the field has clearly accumulated enough best practices to fill a 424-page book, but not enough production-grade systems to validate which of those practices actually matter.