A new proposal for agentic architecture splits a software system into five layers, ordered by how much a human developer controls each one. The model aims to settle a question that many teams answer by accident: which parts of a codebase may an AI coding agent change on its own, and which must a person touch by hand?
The author, a developer who works with several software teams, says those teams all handle coding agents differently and no clear pattern for guardrails has emerged. Conflicts follow. One person’s agent edits an area another person considers off limits, or the reverse. The proposal makes those boundaries explicit.
The inner core
Layers run from the inside out. The first is the core, which the developer owns completely. It holds the conceptual heart of the system, architectural decisions and certain files and folders. Pull requests here are opened and reviewed by a person.
An agent can propose changes to this layer but never makes them. The only exception is a targeted edit that the developer requests directly in an interactive session, and that should be rare. The author says agent output often bleeds into core markdown files in current systems, which makes them brittle and lets them decay. The core has to stay stable and hand-edited.
The outer core
The second layer is the outer core. Agents may edit it in non-interactive sessions, such as a scheduled loop that updates dependencies, but the user must always be told. Technology choices live here, along with components that are central and change only now and then. Think of the design system, secondary markdown files, the frameworks in use, dependency choices and the overall data flow.
Pull requests are often opened by an agent and sometimes by a human. A human always reviews and approves them.
The mantle
The mantle is the first layer where changes no longer come from a person. Agents change it in interactive sessions, non-interactive sessions and loops. The layer is still fairly stable, so the user usually hears about changes, but the agent decides whether a notice is worth sending. For small adjustments it might skip one.
It contains what the user still roughly knows about: design guidelines, pages, application layouts, database migrations, linting rules and some entities in the data model. Pull requests are usually opened by an agent. A human reviews one only if the agent assigns it.
The body and the outer shell
In the fourth layer, the body, the user no longer knows the details. It covers views, specific user flows, how styles are written and how code is structured. These are implementation details, and agents own them. Pull requests are opened and reviewed by agents, and no human reviews them. The user hears about a change only when the agent judges it large enough to mention. If parts of the body are lost, the system gets bugs or unintended behavior but still largely works.
The outermost layer holds temporary files and folders, utility scripts and anything volatile that an agent uses to get its work done. The user does not care about it. Deleting parts of it leaves the system fully functional. Pull requests follow the same rules as the body.
Why people stay in the loop
The author rejects the idea that agents should be allowed to edit everything. Some groups are chasing software factories that take people out of the loop entirely. The author calls that a fallacy and argues there is only so much to automate. Even with today’s models, which will keep improving, the bottleneck is the human at the steering wheel who supplies direction, judgement and taste.
Layering code is nothing new, and the author admits that. Systems thinkers have probably produced similar slicings already. The twist is the cut: layers are separated by who owns what, plus further properties such as how stable a layer must be and who gets told about changes.
What teams could do with it
The practical step is to write the boundaries down. A team can mark which folders belong to the core, which an agent may touch with approval and which it may rewrite freely. Review rules can then follow the layer instead of the mood of the day. A change in the core always goes to a person. A change in the outer shell goes to nobody.
The author is asking for feedback and expects others to refine the layer definitions. If more teams adopt a shared vocabulary of this kind, disputes over agent edits should become easier to settle, because the question shifts from whether an agent should have changed something to which layer the change belongs to.
Source: kairollmann.de