Asset Mgmt Control Plane How It Works | Moring
Architecturally, an AI control plane works as coordinated layers: a policy layer where rules are authored and signed, a decision layer that evaluates each request, an execution layer where agents run, and an evidence layer recording outcomes. Reference architectures state the rule that makes it work: no consumer calls a model directly, so every agent call passes through enforcement the agent cannot bypass.
Short answer
Architecturally, an AI control plane works as coordinated layers: a policy layer where rules are authored and signed, a decision layer that evaluates each request, an execution layer where agents run, and an evidence layer recording outcomes. Reference architectures state the rule that makes it work: no consumer calls a model directly, so every agent call passes through enforcement the agent cannot bypass.
How it works
Reference architecture work on AI governance describes the working structure precisely: separate the policy, the decision, the execution, and the evidence, assign an owner to each, and follow one request end to end to see where a rule becomes an enforced decision. The unifying rule, stated in the AI control plane handbook, is that no consumer calls a model or an enterprise capability directly. Every agent-to-model and agent-to-system call transits the governing layer, which is what makes policy structural rather than advisory.
The policy layer comes first. Rules are authored, reviewed, and signed outside the runtime, then compiled into the form each enforcement point consumes. Analysis of one production agent policy architecture describes signed policy bundles that a policy service verifies and projects into runtime controls, so sandboxes are built from policy the enterprise approved and runtime edits that bypass it are refused. For an asset management firm, this separation means portfolio-policy, compliance rules, and access limits are versioned artifacts with named owners, not settings scattered across agent configurations.
The decision layer evaluates each governed request at runtime against the same signed policy, consulting registered providers for facts when needed, and returning allow, deny, or an edited request. Commentary on the control plane's role frames the questions it exists to answer, which the agent runtime was never designed to address: who authorized this agent to call this tool, has it exceeded its budget, does the credential belong to the human whose task is executing, and did sensitive data head to an endpoint it was not cleared to reach. Deterministic evaluation at a fixed point is what keeps those answers consistent.
The execution layer is deliberately dumb about governance. Framework analysis of agent architecture notes the separation: the agent runtime, whether a vendor platform or an orchestration script, is the execution layer that reasons, plans, and calls tools, while the control plane decides how traffic should be handled. This mirrors the networking split the term borrows. The practical consequence is that governance survives framework changes: an asset manager can replace an orchestration framework without re-deriving its policy posture, because enforcement lives outside the runtime.
The evidence layer records what happened without relying on any component's goodwill. Reference architecture material follows one fictional agent from a suspicious request to a blocked action, an approved change, and the control test an auditor runs afterward, with every record downloadable. Enterprise architecture guidance describes the control plane as what turns written policy into controls that actually execute at runtime, across every model, agent, and data source, and as the difference between a real constraint and a document nobody enforces.
Chokepoint reasoning completes the picture. Analysis of governance-as-code argues that every control needs a place to execute: policy an evaluation point, redaction an interception point, logging an observation point, and cost management a metering point, and that without a common path each control must be implemented separately by every team and kept current as policy changes, which does not happen. For an asset manager operating agents across research, operations, and client reporting, the control plane is that common path, and supervisory expectations for model risk management and EU AI Act traceability are what the evidence layer is built to satisfy.
Frequently asked questions
What are the architectural layers of an AI control plane?
Four coordinated planes: a policy layer where rules are authored, reviewed, and signed; a decision layer that evaluates each request deterministically; an execution layer where agent runtimes reason and call tools; and an evidence layer that records outcomes independently of any component's cooperation. Reference architecture work describes exactly this separation with a named owner for each plane. Asset management firms adopt the structure so portfolio rules, access limits, and compliance constraints exist as versioned artifacts enforced uniformly across the agent fleet.
Why must every agent call pass through the control plane?
Because enforcement only binds calls that transit it. The control plane handbook states the rule plainly: no consumer calls a model or enterprise capability directly, so every agent-to-model and agent-to-system call crosses the governing layer. Governance-as-code analysis adds that without a common path, each control must be implemented separately by every team and kept current, which does not happen in practice. For asset management, a bypass route would let a workflow reach portfolio systems or client records without policy evaluation, defeating the entire control design.
How do signed policy bundles work in a control plane?
Policy is authored and signed outside the runtime, then verified and compiled by a policy service into the form each enforcement point consumes; the runtime builds its sandbox from the approved projection and refuses edits that bypass it. Production architecture analysis of one agent policy system describes exactly this flow, with the policy gateway evaluating each governed request against the same signed policy and returning allow, deny, or edits. Asset management firms gain versioned, owner-attributed rules whose integrity is cryptographically checkable rather than assumed.
What evidence does the architecture produce for auditors?
A complete record of each governed request: the policy version in force, the decision returned, any edits applied, the identity involved, and the outcome, retained independently of the agent runtime. Reference architecture material demonstrates the pattern by following one request from a blocked action to the control test an auditor runs afterward. Asset management supervision applies model risk expectations to the agent layer, and EU AI Act traceability obligations cover autonomous systems, so the evidence layer is designed to satisfy examination reconstruction without special effort.