iTranslated by AI
Learning Architecture with Owls #6-2: The Era of Control Planes & Agents (Design Edition)
This article is a record of personal insights and learning, and does not represent the views of my affiliated organization.
🦉 Learning Architecture with an Owl #6-2
Control Plane & The Age of Agents (Design Edition): The Premises Broken by the Rise of Agents and the 4 "Plane" Model
In Part 1, we explored the background of the birth of the control plane and how Microsoft, Google, OpenAI, and AWS are attempting to manage "agent behavior."
In this article, which serves as Part 2, we will dive deeper:
- Why do traditional IAM, API Gateways, and RBAC fall apart as the number of agents increases?
- What are the three new design challenges necessary for the agent era?
- And how is the "4-Plane Model" (Identity, Authorization, Tool Governance, Observability)—common to all four companies—structured?
This is a domain that was not covered in application-era architecture.
When the lead role shifts from "applications" to "agent behavior," what must architecture redesign?
We will find the answer to that.
#3. The 3 Core Challenges Solved by the Control Plane: Approaching the Essence of the Agent Era (Technical Deep Dive)
The control plane is not a "new idea," but an architecture born as an inevitability of the generative AI era.
The reason is that as the number of agents increases, the challenges faced by enterprise systems have changed both quantitatively and qualitatively.
Here, we will break down those changes into three core challenges for a deeper look.
■ 3-1. Challenge 1: How to Handle Agent "Identity" and "Permissions"?
3-1.1 — Human-centric IAM has reached its limits
Traditional IAM (ID & Access Management) covered "humans," "applications," and "devices."
However, agents...
- Are more numerous than humans
- Act autonomously
- Call APIs in bulk
- Invoke other agents
- Change behavior based on context
- Access external SaaS
Because they have these characteristics, they cannot be managed as an "extension of user accounts."
*Note: Microsoft was the first to define this problem (Reference: Entra Agent ID : https://learn.microsoft.com/en-us/entra/id-governance)
3-1.2 — Microsoft's Approach: Agent ID (Identity-centric)
Microsoft treats "Agents as Employees."
- Hiring (Create)
- Assignment (Role Assignment)
- Salary (Permissions)
- Audit (Action logs)
- Retirement (Disable)
Integrating these with corporate ID Governance is what Agent ID is for.
Technically, the key point is that it optimizes and applies OAuth 2.1, RAR, DPoP, and Token Binding for agents.
🔹 RAR (Rich Authorization Requests)
→ Enables flexible permission control at the action level
🔹 Resource Indicators
→ Clearly specifies "which resource access is for"
🔹 DPoP (Proof-of-Possession)
→ Prevents token "spoofing"
🔹 OAuth 2.1
3-1.3 — Google's Approach: Context Engine (Context-centric)
Google's position is that "permissions change depending on the context."
Example:
- Even for the same agent, permissions change depending on the data set being handled
- If data is highly sensitive, a stronger control layer is inserted
- Access is inferred based on the situation during execution
Context Engine
This is a structure that essentially extends ABAC (Attribute-Based Access Control) with real-time inference.
3-1.4 — OpenAI's Approach: Tool-first (Tool-centric)
OpenAI focuses not on "who" but on "what to execute (tools)."
→ This aligns with the design philosophy of MCP.
🔹 MCP (Model Context Protocol)
By standardizing tool schemas and API call definitions and managing them securely, the philosophy is to avoid giving agents excessive permissions.
■ 3-2. Challenge 2: How to Secure Tool Access (API Calls)?
Many of the risks associated with agents lie in "API calls."
- Calling the wrong API
- Calling with unexpected arguments
- Crossing resource boundaries
- Excessive access to external SaaS
- Sending personal data
Technologies to prevent these are currently being standardized across companies.
3-2.1 — OpenAI MCP (Center of Standardization)
MCP is the standard specification for API access.
Key Features
- Schema (Arguments)
- Capability (List of possible actions)
- Tool invocation (Securing calls)
- Standard state monitoring (Observability Hooks)
Reference:
In particular, the fact that argument validation is performed via schema is an extremely significant advance for security.
Traditional AI Safety was prompt-dependent, but MCP provides structural safety.
3-2.2 — Microsoft FastMCP (High-speed MCP for Enterprises)
It is optimized for enterprise environments, incorporating:
- OIDC
- OAuth 2.1
- Scoped Access
- Token Binding
- On-behalf-of flow
and securing the framework of "Enterprise boundary × Agent × External tools."
*Note: It is highly compatible with the "deny non-permitted tenant model" used by Slack and Box. (Please also refer to my past article: Tokens are allowed but tenants are not — Ending "unauthorized APIs" with OAuth 2.0【Slack/Box Implementation】.)
3-2.3 — Google's Secured Gateway
Google thoroughly enforces "safe exits." When an agent accesses an external system, it enforces the following at the Gateway (exit):
- Data Loss Prevention (DLP)
- Context-dependent permissions
- Metadata attachment
- Policy enforcement
3-2.4 — AWS Guardrails (Input, Output, and Action Control)
AWS provides consistent "infrastructure-centric" controls for:
- LLM input control
- Output filtering
- Application of action guardrails
■ 3-3. Challenge 3: How to Stop Agent "Runaways and Deviations"?
This is the most important theme in the agent era.
- Infinite loops
- Unintended task chaining
- Massive external API calls
- Access leading to high costs
- Accidental transmission of confidential data
Problems that "rarely happen with humans" can occur at any time.
3-3.1 — Observability (Action Auditing)
OpenTelemetry (OTel) is expanding into the agent auditing domain (discussions on Otel for LLM Agents are advancing at various companies).
Key points:
- Logs by Action unit
- Details of Tool invocation
- Referenced context
- API call results
- Detection of anomaly patterns
3-3.2 — Kill Switch (Emergency Stop)
Microsoft, AWS, and Google all emphasize a "mechanism to stop agents."
Examples:
- Forced stop of API calls exceeding a certain threshold
- Isolation when risk scores rise
- Blocked due to DLP violations
- Stop due to action deviation (Policy violation)
OpenAI has also standardized "stop on Tool Invocation failure" in GPTs and the Assistants API.
■ 3-4. The Control Plane is not an "Evolution of IAM" but a "New Layer"
IAM → Access Management
API Gateway → Path Management
Service Mesh → Communication Management
It is different from all of these.
This is because what the control plane handles is "management of Action."
Architecture is being rebuilt centering on "Agent behavior" rather than applications.
This is a decisive difference from the previous series (#1–#5).

Next, I will generate Chapter 4: Common Patterns (Abstract Model) for Control Plane Architecture.
#4. Common Architecture for Control Planes — An Abstract Model Emerging Beyond Vendors
While Microsoft, Google, OpenAI, and AWS have different architectural philosophies, if we decompose and reconstruct the technology layers, the following common patterns emerge.
In this chapter, I will organize the abstract model (common structure across vendors) to grasp the essence of the control plane.
■ 4-1. Overall Model: Redefining Control Plane / Data Plane
In cloud-native,
- Control Plane = Configuration and Permissions
- Data Plane = Actual data processing
However, in the agent era, the meanings change.
🔹 New Structure
Control Plane (Behavior judgment, authorization, and control)
- Agent Identity
- Authorization (Action-level)
- Context / Policy Evaluation
- Tool Governance
- Observability / Kill Switch
Data Plane (Actual tool invocation by the agent)
- API calls
- Tool execution
- External data reference
- Inter-service cooperation
🔹 Differences from the Past
Layered, DDD, Microservices, EDA, and Cloud Native architectures handled Control / Data Planes predicated on applications.
However, in the agent era, because agent groups running within a company exist completely outside the applications,
The control plane becomes an independent layer as a higher-level concept than the application.
This is how the structure changes.

■ 4-2. Abstract Pattern ①: Identity Plane ("Proof of Existence" for Agents)
★ Common Points
- All vendors have introduced "agent-specific IDs."
- Transition from API Keys to "OIDC-based Agent Authentication."
- Strengthened "anti-spoofing" measures via Token Binding / DPoP.
🔹 Example from Microsoft
Entra Agent ID
→ Treated as an OIDC ID for agents.
🔹 Example from OpenAI
Assigning IDs to the "execution entity (run)" for GPTs / Assistants API.
🔹 Example from Google
Context Engine treats "who is operating" as context.
🔹 Example from AWS
Bedrock Agents are isolated via IAM permissions.
■ 4-3. Abstract Pattern ②: Authorization Plane (Authorization of Actions)
Traditional RBAC was a two-dimensional model of role → resource. However, because agents operate centering on "Actions," permission control also shifts to be Action-centric.
★ Common Points
- Action-level Authorization is required
- OAuth 2.0 RAR / Resource Indicators are standardized
- Addition of Context-aware Authorization (led by Google)
🔹 RAR (Rich Authorization Requests)
"actions": ["read", "search"],
"locations": ["users", "messages"]
As shown above,
Granular authorization shifts from the API level to the "Action level."
🔹 Resource Indicators
Clearly specifies "which resources the agent wants to handle."
🔹 Contextual Authorization (Google)
Google dynamically uses context (user, data classification, operating environment).
■ 4-4. Abstract Pattern ③: Tool Governance Plane (Controlling Tool Invocation)
This is the greatest innovation of the control plane.
Since the value of an agent lies in its external tool invocation (= behavior), unless this is secured, the agent may run out of control.
★ Common Points
- Structured tool schema (arguments) to ensure security
- Standardized secure Tool Invocation (MCP)
- Permission at the Action level, not via API Gateway
- Clarified boundaries and permissions for SaaS / DB / Internal APIs
🔹 OpenAI MCP (Center of Standardization)
MCP's "structural safety":
- capability
- tool schema
- request validation
- context injection
provides security that surpasses the App API key method.
🔹 Microsoft FastMCP
Linked with OIDC / OAuth 2.1 / Token Binding to connect naturally with the company's existing IAM.
🔹 Google Secured Gateway
Forcibly controlled at the entrance of external access through DLP, policies, and metadata attachment.
■ 4-5. Abstract Pattern ④: Observability & Kill Switch Plane (Behavior Auditing and Stopping)
★ Common Points
- Action Trace via OpenTelemetry Extension
- Kill Switch for behavioral anomalies
- Isolation based on risk scores
- Detection of tool invocation deviations
🔹 Common to Microsoft / AWS / Google
- Isolation after a certain number of failures
- Blocked upon DLP violations
- Automatic stop of excessive requests
- Immediate denial of unauthorized access
🔹 OpenAI's Structural Safety
Assistants API / GPTs force Tool Invocation errors toward the safe side.
■ 4-6. Summary of the Abstract Model: Control Plane as an Aggregation of "4 Planes"
| Plane | Role | Representative Technology |
|---|---|---|
| Identity Plane | Agent proof of existence | Agent ID / OIDC / Token Binding |
| Authorization Plane | Permission of Actions | RAR / Resource Indicators / Context AuthZ |
| Tool Governance Plane | Control of tool invocation | MCP / FastMCP / Secured Gateway |
| Observability Plane | Behavioral audit / stop | OTel / Kill Switch / DLP |
Even if the philosophies of the four companies differ, they have converged and matched on this abstract model.

It has become clear that the essence of the control plane is a combination of these four planes:
- Identity Plane
- Authorization Plane
- Tool Governance Plane
- Observability Plane
Still, it might be difficult to grasp with just an abstract model.
Therefore, in the final Part 3, I will implement a "minimal control plane" in Python, where we will experience:
- How Action-level Authorization works
- What it means to control tool invocation
- How it maps to real-world FastMCP / MCP / Entra Agent ID
The moment abstraction falls into the concrete — that is Part 3.
Discussion