MAPE-K Loop

The sensory phase of the loop responsible for collecting, filtering, and aggregating data from managed resources.

• Gathers raw telemetry via sensors and probes
• Normalizes heterogeneous data formats into a common model
• Validates data quality and detects missing or stale observations
• Publishes events to trigger analysis when thresholds are breached

Without accurate monitoring, the loop operates on a distorted view of reality, leading to incorrect adaptations.

The diagnostic phase that transforms raw monitoring data into actionable insights through modeling and reasoning.

• Performs symptom recognition and root cause analysis
• Applies predictive models to forecast future states
• Correlates events across multiple subsystems to identify complex fault patterns
• Evaluates the urgency and business impact of detected anomalies

This phase determines what needs to change and why, providing the rationale for subsequent planning.

The decision-making phase that constructs a sequence of actions to achieve a desired target state.

• Generates candidate change procedures based on analysis output
• Evaluates each plan against constraints, policies, and risk profiles
• Selects the optimal path using utility functions or cost-benefit analysis
• Produces a structured workflow ready for execution

Planning transforms diagnostic understanding into a concrete, executable strategy.

The effector phase that carries out the planned actions on managed resources through actuators and APIs.

• Orchestrates the ordered execution of change procedures
• Handles transactional integrity and rollback on partial failures
• Verifies that each step completes successfully before proceeding
• Reports execution status back to the Monitor phase

This phase closes the loop by altering system state, which then becomes new input for monitoring.

The shared state that persists across all phases, providing the contextual memory essential for intelligent adaptation.

• Stores architectural topology, policies, and historical symptom-resolution mappings
• Maintains a registry of known good states and configuration baselines
• Accumulates learned correlations to improve future analysis accuracy
• Enables the loop to adapt faster over time through accumulated experience

Without the Knowledge base, each loop iteration would start from scratch with no institutional memory.

The defining characteristic of MAPE-K is its continuous, self-correcting feedback cycle.

• Output from Execute becomes new input for Monitor
• The system observes the effects of its own actions
• Drift from the desired state triggers automatic re-planning
• Enables self-configuration, self-healing, self-optimization, and self-protection

This property distinguishes autonomic systems from simple scripted automation, which lacks observational feedback.

The Monitor phase is the sensory organ of the loop, responsible for collecting raw data from the managed network environment. In a ZTP context, this involves subscribing to high-frequency streaming telemetry from newly provisioned network functions and the underlying infrastructure.

• Data Sources: gRPC-based telemetry, SNMP traps, syslog events, and Kubernetes resource metrics.
• Key Function: Normalizing heterogeneous data formats into a canonical model for the Analyze phase.
• Example: A Near-RT RIC monitors the CPU utilization and packet drop rate of a newly instantiated vDU (virtualized Distributed Unit) via the O1 interface.

The Analyze phase transforms raw telemetry into actionable insights by applying anomaly detection and root cause analysis models. It determines if the observed state has drifted from the declared desired state defined in the Network Service Descriptor (NSD).

• Techniques: Time-series forecasting, threshold-based alerting, and machine learning-based anomaly detection.
• Output: A specific symptom report, such as 'Cell congestion predicted in sector 12 due to abnormal traffic surge'.
• Integration: This phase often queries the Knowledge base for historical performance baselines to distinguish between a transient spike and a genuine fault.

The Plan phase acts as the decision-making engine, determining the optimal sequence of actions to resolve the diagnosed symptom. It generates a workflow that respects policy constraints defined in Policy as Code.

• Logic: If the Analyze phase detects a fault, the Plan phase queries the Knowledge base for available remediation runbooks or triggers an AI planner.
• Constraint Validation: The plan is validated against capacity limits, security policies, and business intent before execution.
• Example: To resolve a vDU overload, the planner generates a workflow to scale out the vDU instance pool and update the load balancer configuration, ensuring idempotency.

The Execute phase carries out the planned workflow by interfacing with orchestrators and controllers. It translates the abstract plan into concrete API calls to manage the lifecycle of network functions.

• Mechanisms: Calling a Kubernetes Operator to adjust the replica count of a CNF, or invoking a Service Orchestration platform to reconfigure a WAN link.
• Safety: Execution is often staged using canary deployments or blue-green deployments to minimize the blast radius of a faulty change.
• Feedback Loop: The success or failure of each step is reported back to the Monitor phase, closing the loop.

The Knowledge base is the central nervous system of the MAPE-K loop, providing a shared repository of information that the other four phases rely upon. It is not a passive database but an active, evolving model of the managed domain.

• Contents: Desired state configurations (from GitOps), historical performance metrics, topology graphs, policy rules, and a catalog of known failure modes and their remediations.
• Role in ZTP: During provisioning, the Knowledge base holds the golden configuration templates and the Custom Resource Definitions (CRDs) that define the desired state of network slices.
• Implementation: Often backed by a combination of a high-performance key-value store for real-time state and a graph database for topology and dependencies.

A primary application of the MAPE-K loop in ZTP is autonomous drift remediation. This is the continuous process of detecting and correcting configuration drift to maintain the network in its declared, compliant state.

• Process: The Monitor phase detects a configuration change on a device that deviates from the Git repository's source of truth. The Analyze phase identifies this as unauthorized drift. The Plan phase determines the necessary corrective commands, and the Execute phase applies them.
• Outcome: This ensures immutable infrastructure principles are enforced dynamically, providing continuous assurance that the network's actual state matches its intended state without manual intervention.