Agency as an Architecture Layer: A Formal Enterprise Architecture Framework for Agentic-AI-Driven Enterprises

In the modern workplace, a new kind of worker has arrived. It is not a person, but a software agent built on large language models, capable of reading emails, checking databases, and making decisions to complete complex tasks. These agents do not just wait for instructions; they plan their own steps, call upon digital tools, and act on behalf of the organization. For the first time in history, an enterprise must manage a workforce where the workers are not human, yet they hold the power to change records, move money, and alter the state of the business. This shift creates a profound problem for the architects who design how companies work. The blueprints they have used for decades were drawn for a world where only people hold authority and software merely follows fixed rules. Those old maps cannot show where these new, autonomous workers fit, who is responsible when they make a mistake, or whether they have been given too much power to act on their own.

Samir El Hassani, an independent researcher, has proposed a new way to draw these blueprints, a framework that treats these software agents as a fundamental layer of the enterprise, just like the business processes and the technology that supports them. The core idea is simple but necessary: you cannot manage what you cannot see in your model. If an agent is given the authority to pay a claim or approve a loan, that authority must be traced back to a specific human who is accountable for it, and it must be limited to the specific tasks the agent is meant to perform. Without this clarity, organizations risk a chaotic situation where software agents act without coordination, where no one knows who to blame when things go wrong, and where digital workers possess powers they were never meant to have.

To solve this, the researcher developed a system called the Agentic Enterprise Architecture Framework. Imagine the enterprise as a building with several floors. The bottom floors represent the technology, the middle floors hold the applications and data, and the top floors contain the business goals and processes. In the past, the only "actors" on the top floor were people. This new framework adds a dedicated layer for agents, placing them right alongside the human roles. In this model, an agent is not just a tool; it is a principal, a distinct entity that can hold rights and responsibilities. The framework introduces a concept called a "charter," which acts like a contract between the organization and the agent. This charter defines exactly what the agent is allowed to do, the scope of its work, and the human principal who is ultimately responsible for its actions.

The framework distinguishes between four levels of action, ranging from simple reading of information to fully autonomous decision-making. At the lowest level, an agent can only read data. At the next level, it can propose changes that a human must approve. Higher up, it can commit changes that are reversible or confirmed by a process. At the highest level, it can act completely on its own. The system ensures that an agent's power never exceeds the power of the human who gave it, or the agent that delegated the task to it. If a human manager delegates a task to an agent, and that agent delegates a part of the task to another agent, the second agent's power is strictly limited by what the first agent was allowed to do. This prevents a chain of delegation from accidentally creating a super-agent with unlimited authority.

The researchers built a mathematical engine to check these blueprints for errors before any software is actually deployed. This engine looks for seven specific types of problems. It checks for "orphan" authority, where an agent has the power to change records but no human is listed as being accountable for it. It looks for "uncovered" steps, where a business process is supposed to be done by an agent, but no agent has been given the right to do it. It identifies "shadow" authority, where an agent has been granted access to a system that it does not actually need for its work, creating a security risk. It also checks for conflicts, such as two agents trying to change the same record at the same time without a rule to decide who goes first, or a single agent being allowed to perform two tasks that should be kept separate to prevent fraud.

To test if this system works, the researcher applied it to a fictional insurance company. In the first version of the model, the agents were given broad charters, allowing them to act across entire business capabilities. The analysis immediately found dozens of problems. It showed that an agent meant to handle customer intake was accidentally given the power to make final decisions on claims, a job reserved for humans. It revealed that an agent meant to assess damage had been granted the ability to pay out money, a dangerous overlap of duties. It also found that an agent was assigned to a role that no longer existed in the company, leaving its authority unaccounted for. By tightening the charters to match the specific steps the agents were meant to perform, the researcher was able to eliminate most of these errors. The second version of the model was clean, with clear lines of responsibility and no unauthorized overlaps.

The study also tested how well this approach scales to very large organizations. The researchers generated synthetic models containing nearly half a million facts about processes, agents, and resources. The system analyzed these massive models in less than two seconds, proving that the method is fast enough to be used as a routine check in real-world architecture repositories. Furthermore, the study compared this new approach against the way organizations currently manage agents, which usually involves looking only at lists of permissions or simple catalogs. The analysis showed that without the full enterprise model, most of the critical safety checks become impossible. You cannot see if an agent is acting without oversight, or if two agents are conflicting, if you only look at a list of permissions without understanding the business process they are part of.

The findings suggest that the way organizations manage software agents needs a fundamental shift. Relying on runtime controls, which monitor agents as they act, is not enough. The safety and coherence of these systems must be designed into the architecture itself. By adding a layer for agency to the enterprise model, organizations can ensure that every action taken by a software agent is justified, traceable to a human, and confined to the scope of its intended work. This framework does not stop the agents from acting; instead, it provides the structure that allows them to act safely and effectively within the complex web of a modern business. It turns the question of "who is in charge?" from a vague worry into a precise, answerable part of the design.