2 The evolving role of the architect

Enterprise architecture has traditionally focused on deciding who may decide before a system goes live, then relying on that design-time approval to hold in production. The chapter argues that agentic systems break this model because they continue making decisions at runtime, at machine speed, and often between governance cycles. As a result, architects can no longer stop at sign-off; they must design for continuous supervision, clear delegation, and timely intervention so autonomy delivers value without undermining trust.

To govern delegated autonomy, the chapter introduces six practical principles: autonomy must be bounded, attributable, observable, governable, safely transferred at its limits, and continuously realigned as conditions change. These principles are meant to be operational rather than abstract, giving architects a way to judge whether autonomous behavior is legitimate and under control. The chapter also shows why familiar frameworks remain useful for structure and coordination, but are incomplete for systems whose behavior evolves after deployment and must be managed in motion.

The architect’s role therefore shifts from blueprint maker to guardian of trust and resilience engineer. That means building runtime supervision mechanisms such as observability, policy-as-code, escalation paths, and orchestration, while also designing teams and handovers so humans and agents can collaborate safely. Through examples like a hospital drift intervention and agentic team models, the chapter emphasizes that autonomy must be treated as a supervised decision space: observable, correctable, and accountable across both technical and organizational boundaries.

Design-time governance as blueprint approval. Traditional enterprise architecture governs behavior before deployment with reviews, approvals, and static design artifacts. Once systems cross the deployment boundary, runtime behavior is assumed stable, and governance largely recedes into operations.

Architecture as runtime supervision. The diagram shows four components working as a continuous control loop. Observability sensors detect drift in the agent's behavior. The autonomous decision space is where agent actions occur, constrained by the autonomy boundary. The governance engine evaluates policy against intended actions before those actions execute and adjusts the decision space over time as conditions change. Together, these components supervise delegated authority rather than intervening in individual decisions.

Decision Output and Escalation, showing how authority and context move across the team boundary. Within the boundary, humans and agents operate as peer nodes with designed coordination paths rather than through informal collaboration.

Conway's Law at machine speed. Two agents authorized by different organizational silos enter a high-frequency conflict loop, cycling through offer-and-revoke four times in thirty seconds. The customer sees the discount appear and disappear repeatedly before canceling out of frustration. Each agent operates correctly within its delegated authority; the failure is architectural. No mechanism exists for shared intent or conflict resolution.

• Traditional enterprise architecture frameworks (TOGAF, Zachman, SAFe) remain valuable for structure and coordination, but they assume that meaningful decisions about behavior are made before deployment. Agentic systems continue making decisions at runtime, creating an agentic architecture gap that these frameworks do not address.
• Six principles close this gap: autonomy must be bounded, attributable, observable, governable, safely transferable at its limits, and continuously realigned. Together, they define the conditions under which delegated autonomy remains legitimate in the enterprise.
• Boundaries are not rules or workflows. They define the limits of decision-making authority: what autonomy may do, where that authority applies, and when it must stop, without prescribing how decisions are reached.
• Observability for agentic systems moves beyond system health metrics to decision observability by treating autonomous decisions as first-class events and tracking patterns such as proximity to boundaries, clustering within permitted space, and behavioral drift over time.
• Continuous governance shifts oversight from episodic review to ongoing supervision. It operates on signals rather than failures, adjusting the envelope of delegated authority instead of intervening in individual decisions.
• The architect's role evolves from Blueprint Maker to Resilience Engineer, designing not just what systems are, but how they behave under live conditions. This includes the resilience loop: autonomy boundaries, observability sensors, the policy engine, and escalation triggers.
• Human oversight in agentic systems is not about reinserting humans into every decision. It is about designing the conditions under which authority transfers back to humans when autonomy reaches its limits, with sufficient context for effective intervention.
• Three skills become essential: simulation to explore behavior under uncertainty, policy-as-code to express intent in machine-enforceable form, and orchestration to coordinate decision-makers rather than sequence tasks.
• Organizational design must evolve to treat agents as functional nodes within teams, not merely as tools. The Team–Agent Contract defines delegated authority, escalation protocols, and audit trails. Without this contract, organizations are not ready to delegate autonomy.
• Conway's Law operates at machine speed in agentic enterprises. Organizational silos, when encoded into autonomous agents, produce systemic dysfunction rather than localized inefficiency, making architectural clarity about shared intent and conflict resolution essential.

FAQ