1.3 The Agentic Substrate

Engineering methods have to fit the substrate they act on. Reinforced concrete works because concrete takes compression and steel takes tension; where the reinforcement goes follows from those properties. Agentic software engineering likewise begins by asking what productive machinery has entered the engineering process and which of its properties matter.

For MAGE, the relevant substrate is not a foundation model alone. It is a foundation model operating through an agentic harness inside an engineered environment. The combination determines both what autonomous work can do and where engineering can act on it.

1.3.1 Foundation Model and Agentic Harness

A foundation model supplies broad, inexpensive semantic reasoning. An agentic harness—the runtime around it—turns reasoning into action by supplying tools, lifecycle, state, and points where work can be observed or stopped. The useful unit is the pair operating inside an engineered environment.

Four properties of the foundation model matter to the engineering argument:

• Broad semantic reasoning. A foundation model can interpret, synthesize, and search across open-ended domains. Give it an abstraction—a schema, state table, or policy—and it can reason about that abstraction rather than merely execute a fixed script.
• Probabilistic output. Repeated runs can differ, and the foundation model's confidence in its own result is not independent evidence that the result is correct. The producing run cannot establish engineering authority merely by affirming its own output.
• Bounded working state. Active reasoning state is finite. Durable system knowledge must therefore persist outside the producing run and be supplied, retrieved, or reconstructed when later work needs it. A harness can improve that process; it cannot make active reasoning state unbounded. External memory and retrieval are established responses to this constraint in AI systems. Modeling asks a different question: which state and relations are worth making explicit in the first place.
• Cheap repeated reasoning. Search, generation, repair, and reconciliation—reasoning work that once consumed substantial engineering labor—can now be repeated at previously impractical scale.

The harness contributes four complementary properties. A foundation model produces outputs; the harness turns those outputs into action and exposes the boundaries through which that action passes.

• Tool-mediated action. The agent touches the world only through identifiable interfaces — a file edit, a command, an API call.
• Interposition. Because every action crosses an interface, a hook or wrapper can inspect it, constrain it, redirect it, or deny it at the moment it happens.
• Lifecycle visibility. Dispatch, tool calls, compaction, completion, merge, deploy — the work's transitions are machine-observable events, not private states in a worker's head.
• Parallel execution. Many independent reasoning loops run at once, on one codebase, around the clock.

None of these properties is wholly alien to human software engineering. Humans also reason with bounded state, make uncertain judgments, use tools, and rely on evidence outside themselves. What changes is the combination: broad semantic work is now cheap and repeatable; implementation can proceed in many parallel reasoning loops; and the harness exposes machine-observable boundaries around that work. Recent work on harness engineering similarly treats autonomous capability as a property of the foundation-model–harness–environment system rather than the foundation model alone ¹1. Hailin Zhong and Shengxin Zhu, “AI Harness Engineering: A Runtime Substrate for Foundation-Model Software Agents,” 2026, https://arxiv.org/abs/2605.13357. ²2. Justin Young, “Effective Harnesses for Long-Running Agents,” Anthropic, November 26, 2025, https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents. ³3. Garry Tan, “Thin Harness, Fat Skills,” April 9, 2026, https://github.com/garrytan/gbrain/blob/master/docs/ethos/THIN_HARNESS_FAT_SKILLS.md.. Figure 1.3-1 shows that combination. This substrate changes the economics of old engineering problems and exposes new places to act on them.

1.3.2 The Reasoning Horizon

Scale creates a reasoning problem before an agent ever enters the picture. A sufficiently large software system exceeds what one engineer can keep actively in mind; agentic work inherits the same condition. A long engineering task is not a prompt and an answer but a campaign: read the system, form a plan, make a change, inspect the result, reconcile what changed, and carry consequential earlier decisions into the next step. The reasoning state required by that campaign grows. The active state available to the reasoner remains finite.

Once the task outruns active working state, some of that state has to live elsewhere and be reconstructed when needed. The reconstruction may be excellent or poor. If the reasoner repeatedly rebuilds its picture from raw implementation, loose notes, or lossy compaction, relevant decisions disappear into irrelevant detail: solved questions are re-solved, earlier constraints are contradicted, and context has to be rediscovered. That recurring reconstruction cost is one source of churn. Figure 1.3-2 shows the mechanism.

Agent harnesses respond through context management, including compaction: compressing earlier working state so that a session can continue within a bounded context window. Compaction extends a reasoning episode, but it does not remove the underlying problem: compressed state can lose distinctions that later reasoning requires.

Better representations can move the boundary by using available working state more effectively; they do not abolish the underlying locality problem. We already see both effects. RULER found that effective context length can fall well short of advertised context length and vary substantially across foundation models ⁴4. Cheng-Ping Hsieh et al., “RULER: What's the Real Context Size of Your Long-Context Language Models?,” 2024, https://arxiv.org/abs/2404.06654.. Lost in the Middle showed that a fact's presence inside a long context does not make it equally available to the reasoner ⁵5. Nelson F. Liu et al., “Lost in the Middle: How Language Models Use Long Contexts,” Transactions of the Association for Computational Linguistics (TACL) 12 (2024), https://arxiv.org/abs/2307.03172.. A stronger reasoner may recover relevant state more effectively. It still operates with finite active state.

Independent practice reports a related effect at codebase scale. Sourcegraph's study of 1,281 scored agent runs across more than 40 large open-source repositories found that agents navigating by following raw references increasingly built exploration trees they could not prune effectively as repositories grew ⁶6. Sourcegraph, “Why Coding Agents Fail in Large Codebases,” Sourcegraph, 2026, https://sourcegraph.com/blog/why-coding-agents-fail-large-codebases.. The relevant point is not a magic line-count threshold. Raw implementation is an expensive reasoning substrate when the engineering question depends on a much smaller set of relationships.

1.3.3 The Horizon Is a Locality Problem

Seen this way, the reasoning horizon is not an exotic property of language models. It is another instance of a familiar systems problem: useful state must be kept close enough to the computation that consumes it. Caches, virtual memory, and distributed systems all reorganize computation around finite and unequal access to state. Agentic reasoning presents an analogous locality problem for reasoning state.

Larger context windows, persistent memory, retrieval systems, or new neural architectures will move the boundaries and change the constants. They do not remove the underlying engineering problem. For sufficiently large tasks, question-relevant state must remain available and cheap enough to reason over while irrelevant detail stays outside the active working set.

The reasoning-horizon problem is broader than context-window length. Retrieval, summarization, compaction, and external memory can make more raw state available to a reasoner. They do not decide which abstraction makes the engineering property tractable. A dependency graph can answer a question that thousands of retrieved source lines merely make available; a state machine can expose a behavioral property that additional context leaves implicit. MAGE is therefore concerned with semantic compression through purposeful representation, not merely with fitting more information into a reasoning episode.

1.3.4 Probabilistic Work Needs External Authority

The second problem is not that agents make mistakes while human programmers do not. Software engineering has always separated authorship from assurance. We compile code instead of trusting the programmer's prediction that it compiles; we run tests instead of accepting an explanation that the program should work; consequential systems add review, static analysis, formal methods, operational evidence, or independent approval because the producer's confidence is not enough.

Cheap, fast, repeatable agentic production makes that separation more consequential. An agent can propose a change, inspect it, explain it, and often repair it, but another probabilistic judgment from the same productive substrate does not automatically create engineering authority. If an obligation matters, the environment must establish what evidence counts and what follows when the obligation is not met.

1.3.5 Agentic Work Has Observable Seams

Agentic work occurs through observable interfaces. Whatever internal computation produces a proposed action, consequential work reaches the engineering system through inputs, tool calls, edits, outputs, and lifecycle transitions. Those boundaries give the engineered environment places to observe, constrain, validate, or stop the work.

Useful local controls already operate at these seams without a system model: a sandbox can deny network access, a hook can reject a command, and a test can block a regression. Explicit engineering models can extend the semantic reach of those same control points. An action can then be judged not only by what it immediately does, but by what it means for architecture, policy, behavior, ownership, measurements, or other represented obligations.

The harness supplies the control points; representation determines what those control points can know.