Agent Architecture Weekly

Architecture-Native Agent Steering Versus Prompt Engineering

Durable architectural constraints in code beat temporary prompt instructions for steering AI agents.

Sponsored by Graphide

Agent Architecture Weekly Editors
· 9 min read
Cover illustration for “Architecture-Native Agent Steering Versus Prompt Engineering”
Agent Workflow Patterns · November 4, 2026 · 9 min read · 1,993 words

An interactive codebase graph for AI agent steering gives developers a live, machine-readable map of code structure on which to direct agent work and check architectural conformance. Prompt engineering specifies what an agent should do in one interaction. Architecture-native steering sets what an agent can understand, access, and keep across interactions through repository context that lasts and constraints that can be enforced, without relying on ever more detailed instructions.

Why prompt engineering has a structural ceiling, not just a quality ceiling

By the fifth prompt rewrite, the same class of mistake points beyond wording. An agent duplicates an internal utility that already exists elsewhere, imports a banned dependency, or couples modules the architecture has deliberately kept apart. Each change may look right in the files being edited. The failure is structural. The agent has acted without enough knowledge of the environment in which its change must fit.

The usual response is to add more instructions. Repository conventions get added alongside security rules, deployment constraints, and architectural principles until the prompt reads like a small operating manual. That expansion can improve the next interaction, but it also reveals a mismatch between the information and its container. Permanent design knowledge is being restated as temporary conversational context. Architecture is pretending to be a prompt.

A prompt belongs to a session and must be supplied again when that context disappears. Module boundaries, service responsibilities, and forbidden dependencies remain properties of the codebase whether an agent has been told about them or not. Prompt quality can improve compliance with instructions the agent receives, but it cannot make a chat turn the durable authority for an engineering environment.

What agents actually need that prompts cannot supply

Reliable execution begins with more than a task description. The Catalyst Context Stack treats immediate intent as separate from repository knowledge, architectural constraints, operational permissions, and organizational memory. Immediate intent includes the desired outcome, the boundary of the work, and the evidence that would establish acceptance. “Fix this” leaves those questions unanswered. Yet answering them still does not tell an agent where the change belongs.

Repository knowledge supplies that next layer of context. It distinguishes directories that represent domain boundaries, modules that serve as stable interfaces, generated files, and preferred abstractions. Architectural constraints explain which layers must remain separate, which services own particular responsibilities, and which patterns have been retired. Operational constraints set out what the agent may run and what it needs explicit approval to do. Organizational memory preserves earlier decisions that still govern the present task.

These inputs serve distinct purposes. Without a repository map, an agent can produce code that is locally sound but globally misplaced. A function may work while putting responsibility in the wrong module, and a convenient import may violate a boundary invisible in the immediate file. Architecture held only in people's heads cannot constrain machine execution. Tribal knowledge about forbidden couplings is absent from the agent's decision process.

The industry's convergence reflects this shared information problem. CLI-first agents, agents native to development environments, and cloud engineering platforms increasingly combine memory files, repository awareness, and long-running execution. Their interfaces differ, but the underlying requirement is similar. Sustained work needs context that outlasts the latest request and connects individual edits to the system around them.

How architecture-native steering actually works as an engineering layer

Architecture-native steering moves durable knowledge into the repository so agents can consume it on every run. Memory files set out the project's architecture, development conventions, deployment processes, and testing requirements so an engineer need not repeat them in each prompt. AGENTS.md files spell out how the repository is structured and what its constraints are. Strongly typed contracts make boundaries clear in the code itself. Deliberately pruned retrieval helps make the relevant architectural context discoverable without burying it in unrelated material.

A refined prompt improves a particular execution, while durable, machine-readable context reduces the work needed to orient future executions. The repository becomes the persistent home for knowledge that would otherwise be reconstructed session by session. That does not make documentation authoritative by itself. An agent can still ignore, truncate, or misinterpret AGENTS.md, so recording intent and enforcing it remain separate engineering tasks.

Tsinghua University's Model-Native Computing Architecture paper offers a way to think about that separation. Its conceptual survey distinguishes a probabilistic execution plane, concerned with what can be computed, from a deterministic control plane, concerned with what should be computed. This is an analogy. Its value here is to distinguish the agent's generative work from the controls that govern acceptable execution.

Classical computing makes the distinction easier to see. An operating system enforces resource boundaries that individual applications cannot override. In the same way, an architecture-native layer needs to make structural boundaries explicit and machine-readable rather than entrusting them to the interpretation of each prompt. Repository documentation supplies part of that layer, but the analogy becomes operational only when constraints have consequences.

Why CI enforcement is what makes the constraint layer load-bearing

A constraint that can be bypassed without consequence remains advice. A rule becomes structural when its violation causes a CI gate to exit non-zero and block a merge. For a linter, reviewer, or architecture checker, the decisive criterion is whether failure prevents acceptance. A style guide or advisory lint result cannot provide the same guarantee as a required gate.

Architecture tests make that consequence concrete across several stacks. ArchUnit supports Java, dependency-cruiser supports JavaScript, import-linter supports Python, and NetArchTest supports.NET. Integrated into CI/CD, such tools can prevent a build from passing when an encoded architectural rule is violated. Their protection follows the rules actually specified. They cannot enforce a boundary that has never been expressed in a form they can check.

AI reviewers provide another layer of scrutiny, but their findings depend on the quality of the underlying constraint specification. Documentation and skills remain necessary for understanding the intended design, yet neither is a substitute for enforcement. The distinction also extends beyond static checks. Constraints such as “no N+1 queries” and “no direct unencrypted access to sensitive data” require runtime guards, including middleware, query interceptors, or encryption wrappers.

The DORA finding links this difference in engineering practice to how well teams deliver software. AI adoption without corresponding investment in small batch sizes and robust testing correlated with measurable delivery stability regressions. The architectural causes of individual regressions remain unproven. It still calls into question the belief that faster generation can work apart from delivery controls. More autonomous execution still depends on robust acceptance mechanisms.

What Cloudflare's CI-native system shows about architecture predating the prompt

Cloudflare's initial attempts exposed the limits of prompt-first review. Existing AI tools were insufficiently customizable, and a subsequent approach that fed diffs into LLMs with basic prompts produced vague suggestions, hallucinated syntax errors, and unhelpful advice. The feedback lacked a dependable connection to the organization's engineering standards.

Cloudflare's Engineering Codex supplied a centralized repository of standards intended for both engineers and AI agents. It tackled the drift and loss of shared knowledge that arise when guidance is spread across wikis, repositories, and chat threads. Auto-generated AGENTS.md files brought that context to thousands of repositories. Standards preceded the agents' implementation work. A Spec Reviewer Agent also checked technical designs against the Codex requirements that applied before implementation began.

The review workflow brought those standards into CI. When an engineer opens or updates a merge request, a CI job runs the open-source OpenCode agent with a multi-agent review coordinator. The coordinator classifies the request by risk tier before delegating to specialized reviewers. Up to seven reviewers cover security, performance, code quality, documentation, release management, compliance, and AGENTS.md review. The wider system includes 13 MCP servers with more than 182 tools.

Specific rule references make the feedback more useful. The AI Code Reviewer ties its findings to Codex rules by citing them. Backstage and AGENTS.md supply the knowledge layer, the Codex defines enforcement standards, and the reviewer applies them within the workflow. Cloudflare describes the first agent draft as usually close enough to ship when those parts work together.

Anthropic's 2026 agentic coding report supplies a narrower supporting example of scale. Rakuten engineers completed a seven-hour single-run implementation on the 12.5-million-line vLLM open-source codebase, validated against a pre-existing numerical accuracy reference. That example illustrates why substantial autonomous work needs an existing environment and acceptance evidence beyond the wording of the request.

The conformance gap that standard toolchains still leave open

Even with repository instructions, linting, and CI gates, a conformance gap remains. Standard toolchains do not yet provide the complete layer that compares the dependency graph of generated code against declared architectural constraints. Teams must custom-build that integration. Individual checks can enforce known dependency rules without providing a general account of how generated changes reshape the system.

The gap is visible when agents make architectural decisions during what looks like routine implementation. Agents can choose a framework, scaffold infrastructure, and wire integrations in seconds, while those choices get little review for their effect on the architecture. A rule such as “no new database dependencies without review” needs a mechanism that detects the change and connects it to the required review. Writing the rule alone does not supply that mechanism. Existing gates may check other things and still let the decision go unnoticed.

AI-assisted pull requests are substantially larger than unassisted ones, and a large diff can overwhelm a human or AI reviewer's context. Frequent increments that look mostly right make subtle design drift progressively easier to overlook. This is the cognitive surrender risk. Confidence in the agent's usual output can erode scrutiny precisely where individual edits appear plausible.

Compilation and baseline tests do not settle architectural correctness. Generated code can follow style guides while introducing unsuitable patterns, drifting from linked tickets, or changing files beyond the original scope. These failures identify the missing representation needed to compare what an agent has built with the design it was meant to preserve.

How does a live architecture graph close the gap left by static rules and diffs?

A live architecture graph shows how the code is actually connected as the agent works. For interactive codebase graph steering, the defining criteria are structural coverage, freshness, repository versioning, and a machine-readable form that CI rules can evaluate. Visual navigation is useful but not sufficient. The same map must support the agent's context and the engineer's assessment of the resulting architecture.

The intended coverage includes every module, file, class, function, and call relationship. Those relationships must be kept up to date as code changes, instead of showing a design drawn once and left behind. A diff shows which lines changed but leaves out the full call graph and pattern of module coupling that result. The graph supplies that missing structural view. An engineer can then direct work through code relationships rather than infer the system's shape from isolated patches.

Repository versioning connects that view to the code it describes. The graph lives in the repository and versions with the implementation, while declared constraints run against its machine-readable structure in CI. Static rules still define the prohibited relationships. The graph gives conformance checks a current representation of the code to evaluate.

This changes where engineering attention can be applied. The engineer can plan agent work at the architectural level, inspect whether the code on disk matches the intended design, and run enforcement checks automatically. Unexpected coupling can be seen even before a rule has been written to catch it. The graph therefore supports both human steering and machine enforcement, which solve different parts of the same problem.

Cloudflare's system shows how much work it takes to bring context, standards, and review together. With a live repository graph, structural conformance could become a first-class CI primitive, removing the need for another custom link between instructions and checks. With explicit constraints evaluated against current code relationships, the question of whether agent-generated code matches the declared architecture becomes answerable automatically on every merge. The prompt can then specify the task without having to stand in for the codebase.

Sources

  1. Model-Native Computing Architecture: Envisioning Future System Architecture Through the Lens of Computer Architecture

More in Agent Workflow Patterns