MAPE-K

The reference control loop of Autonomic Computing and self-adaptive software: an autonomic manager runs a closed feedback loop of Monitor → Analyse → Plan → Execute over a shared Knowledge base, acting on a managed element through sensors (probes/gauges) and effectors.

Monitor — collect and aggregate sensor data from the managed element and its environment.
Analyse — detect when adaptation is needed (symptoms, constraint/SLA violations, drift from goals).
Plan — select a course of action (a strategy/tactic, reconfiguration, or repair).
Execute — enact the plan through effectors on the managed element.
Knowledge — models, policies, goals, and history shared across the four phases (see Models@run.time).

Introduced in The Vision of Autonomic Computing (Kephart & Chess 2003) as the organising abstraction for the self-* properties (self-configuration, self-healing, self-optimisation, self-protection). It is the connective tissue linking architecture-based adaptation (Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure), reference models (Three-Layer Reference Model), and the broader survey landscape (Self-Adaptive Software - Landscape and Research Challenges).

In this vault

Backlinks

Linked Pages

Models@run.time

The principle that a self-adaptive system should keep a causally-connected, runtime-accessible model of itself (and often of its environment and goals) that both reflects the running system and can be used to reason about and drive adaptation. Where classic model-driven engineering uses models at design time, models@run.time extends abstract models into the running system as first-class artefacts that the adaptation logic queries and updates.

Such a runtime model is the natural home for the Knowledge in a MAPE-K loop: the Monitor phase keeps it in sync with reality, and the Analyse/Plan phases reason over it rather than over raw code. Architecture-based approaches like Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure make the software architecture the runtime model against which constraints are evaluated and repairs planned.

Three-Layer Reference Model

A reference architecture for self-managed systems proposed in Self-Managed Systems - an Architectural Challenge (Kramer & Magee 2007), adapting Gat’s three-layer architecture from autonomous robotics to self-adaptive software. It separates adaptation concerns by the timescale and abstraction at which they operate:

Component control — the running application; components self-tune and report status, with mechanisms to add, remove, and reconnect components at runtime.
Change management — a set of pre-computed plans that react to status reports and execute reconfigurations; escalates to the layer above when no applicable plan exists.
Goal management — produces new plans from high-level goals (typically slow, deliberative planning) in response to requests from change management or changes in goals.

The model is a widely-cited way to structure the Plan/Execute portions of a MAPE-K loop across abstraction layers, and frames the open research challenges (requirements, assurance, decentralised control) of the field.

In this vault

Runtime Assurance

The provision of continuous, runtime evidence that a self-adaptive system still satisfies its requirements as the system, its environment, and its workload change — replacing (or supplementing) one-shot design-time verification with an incremental, always-on activity. Because self-adaptation defers decisions to runtime precisely to cope with uncertainty, the guarantees must be re-established at runtime too; the SEAMS roadmaps call this perpetual assurance and treat it as the field’s defining challenge.

Runtime assurance is realised through several complementary techniques in this vault: quantitative (probabilistic) verification at runtime (Self-Adaptive Software Needs Quantitative Verification at Runtime), executable verified formal models of the feedback loop (ActivFORMS - Active Formal Models for Self-Adaptation), and control-theoretic guarantees synthesised for the adaptation controller (Automated Design of Self-Adaptive Software with Control-Theoretical Formal Guarantees). All of them keep a runtime model in the MAPE-K knowledge base and re-check goals against it as conditions drift.

In this vault

Control Theory

The engineering discipline of designing feedback controllers that drive a system toward a reference goal despite disturbances, and of analysing the resulting closed loop for properties such as stability, accuracy, settling time, and overshoot (the “SASO” properties). In self-adaptive software it is the rigorous underpinning of the Feedback Loop / MAPE-K stance: if an adaptive system is really a control loop, control theory supplies both the design methods and the guarantees.

The line runs from Feedback Control of Computing Systems (Hellerstein et al. 2004), which imports classical control into computing-systems performance management via system identification and controller design, through Engineering Self-Adaptive Systems through Feedback Loops (Brun et al. 2009), which argues the loop should be a first-class artefact, to Automated Design of Self-Adaptive Software with Control-Theoretical Formal Guarantees (Filieri, Hoffmann & Maggio 2014), which automates controller synthesis so software engineers get formal guarantees without doing the control-theory design by hand.

In this vault

Feedback Loop

A control structure in which a system observes the effect of its own actions (or of environmental change) and feeds that observation back to adjust subsequent behaviour toward a goal. Feedback control is the engineering backbone of self-adaptation: the MAPE-K loop is a feedback loop whose sensor readings (Monitor) close back onto the actions taken through effectors (Execute).

Making the feedback loop a first-class, visible architectural element — rather than logic buried in application code — is a recurring theme of the self-adaptive-systems literature and connects the field to classical control theory (stability, settling time, overshoot) as a source of design and assurance techniques.

In this vault

Self-Adaptive Systems

Systems that monitor and modify their own behaviour: self-organisation, self-expression, self-awareness.

Autonomic Computing

A software-engineering tradition, launched by IBM’s 2001 manifesto and crystallised in The Vision of Autonomic Computing (Kephart & Chess 2003), that responds to spiralling system complexity by building systems that manage themselves given high-level objectives. The biological metaphor is the autonomic nervous system: low-level regulation happens without conscious control so the administrator specifies what is wanted, not how to achieve it.

Autonomic systems are organised as MAPE-K loops — autonomic managers regulating managed elements — and are judged by the self- properties*: self-configuration, self-healing, self-optimisation, and self-protection (collectively “self-CHOP”). The tradition is the engineering counterpart to the biology-inspired Self-Adaptive Systems line already in this vault: where the latter asks why systems adapt, autonomic computing asks how you build and assure the adaptation.

In this vault

Metacognitive Loop

Self-monitoring feedback loop in which an agent observes its own behaviour against expectations and revises.

In this vault

Self-Adaptation

A system’s capability to modify its own behaviour or structure at runtime in response to internal or environmental change, without external intervention. It is typically implemented as a MAPE-K loop (Monitor-Analyse-Plan-Execute over a Knowledge base), the control abstraction introduced by Autonomic Computing.

In this vault

ActivFORMS - Active Formal Models for Self-Adaptation

ActivFORMS: Active Formal Models for Self-Adaptation

Reference: Iftikhar, M. U. & Weyns, D. (2014). ActivFORMS: Active Formal Models for Self-Adaptation. In Proc. 9th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS 2014), ACM, pp. 125–134. DOI: 10.1145/2593929.2593944. URL

Summary

ActivFORMS (“Active FORmal Models for Self-adaptation”) is an approach in which a formal model of the feedback loop is not merely used to verify a design and then discarded, but is directly executed as the running adaptation logic. The feedback loop’s MAPE-K behaviour is specified as a network of timed automata; those automata are verified against the adaptation goals (using model checking, e.g. Uppaal), and then the same verified model is deployed and executed by a virtual machine that interprets the automata at runtime. Because the artefact that runs is the artefact that was verified, ActivFORMS closes the usual gap between a verified design and the code that actually executes.

The approach’s second contribution is on-the-fly change of the adaptation logic with guarantees: because the executing model is a first-class runtime object, a new (re-verified) feedback-loop model can be installed at runtime to change how the system adapts, extending assurance from the managed application to the manager itself. ActivFORMS is a flagship example of models@run.time used for assurance: the running formal model is simultaneously the system’s knowledge, its executable controller, and the object of verification. Weyns and collaborators later extended it with runtime goal management and statistical model checking, and it stands as a canonical answer to the roadmaps’ call for practical runtime assurance of self-adaptive systems.

Key Ideas

Executable verified models: specify the MAPE-K feedback loop as timed automata, verify them, then directly execute the verified model — no separate hand-coded controller.
A model-execution virtual machine interprets the automata at runtime, eliminating the design-to-code assurance gap.
On-the-fly adaptation of the adaptation logic: install a new, re-verified feedback-loop model at runtime with retained guarantees.
Extends assurance to the managing system, not just the managed application.
A leading instance of Models@run.time for assurance; later extended with runtime goal management and statistical model checking.

Connections

Conceptual Contribution

Claim: Assurance for self-adaptive systems is strongest when the verified formal model of the feedback loop is itself executed, so the running adaptation logic and the verified artefact are one and the same — and can be replaced at runtime with retained guarantees.
Mechanism: Model the MAPE-K loop as timed automata, model-check them against goals, and run the verified model on a model-execution virtual machine as a first-class Models@run.time object that can be swapped for a re-verified model on the fly.
Concepts introduced/used: Runtime Assurance, Models@run.time, MAPE-K, Formal Verification, Feedback Loop
Stance: engineering / framework
Relates to: The formal/model-based counterpart to the probabilistic Self-Adaptive Software Needs Quantitative Verification at Runtime; a concrete realisation of the perpetual-assurance agenda in Software Engineering for Self-Adaptive Systems - A Second Research Roadmap.

Tags

Self-Adaptive Software Needs Quantitative Verification at Runtime

Reference: Calinescu, R., Ghezzi, C., Kwiatkowska, M. & Mirandola, R. (2012). Self-Adaptive Software Needs Quantitative Verification at Runtime. Communications of the ACM 55(9): 69–77. DOI: 10.1145/2330667.2330686. URL

Summary

This paper argues that self-adaptive software must move a class of quantitative analysis from design time into runtime. Non-functional requirements — reliability, availability, performance, cost — are often stated probabilistically or in terms of expected costs/rewards, and the standard design-time way to establish them is quantitative (probabilistic) model checking over Markov models (DTMCs/MDPs, CTMCs) using tools such as PRISM. The authors’ thesis is that because the environment, workloads, and component behaviours a system actually meets are only known once it is running — and keep changing — the same quantitative verification must be re-run continuously, at runtime, to check whether requirements still hold and to guide adaptation when they do not.

Concretely, the approach keeps an operational stochastic model of the system as part of the Knowledge (a Models@run.time artefact), continuously updates its parameters from monitored data (e.g. observed failure rates, response times), and re-verifies the relevant probabilistic/reward properties against that model. When verification predicts a requirement violation, the results drive the Plan step — selecting a reconfiguration whose verified properties restore the guarantees. The chief engineering challenge the paper foregrounds is efficiency: full model checking is expensive, so runtime use demands incremental and parametric verification techniques so the analysis can keep pace with adaptation. The work is a cornerstone of the runtime-assurance agenda, giving self-adaptation continuous, evidence-based guarantees rather than one-off design-time certificates.

Key Ideas

Move quantitative verification from design time to runtime: continuously re-check probabilistic/reward requirements as conditions change.
Keep an operational stochastic model (DTMC/MDP/CTMC) in the system’s runtime knowledge, updated from monitored data.
Verification results drive adaptation: a predicted violation triggers selection of a reconfiguration with verified properties.
Targets non-functional requirements — reliability, performance, availability, cost — that are naturally quantitative.
Central obstacle is efficiency; needs incremental/parametric model checking to run within the MAPE-K loop’s time budget.

Connections

Conceptual Contribution

Claim: Because the conditions under which non-functional requirements must hold are known only at runtime and keep changing, quantitative (probabilistic) verification has to be performed continuously at runtime, not once at design time.
Mechanism: Maintain a parametric stochastic model of the system in the runtime knowledge base, update it from monitored data, and re-run quantitative model checking (reliability/performance/cost properties) to detect predicted violations and choose verified reconfigurations — using incremental/parametric techniques for efficiency.
Concepts introduced/used: Runtime Quantitative Verification, Runtime Assurance, Models@run.time, MAPE-K, Formal Verification
Stance: engineering / position + method
Relates to: A concrete realisation of the perpetual-assurance goal of Software Engineering for Self-Adaptive Systems - A Second Research Roadmap; the probabilistic counterpart to the model-based runtime formal methods of ActivFORMS - Active Formal Models for Self-Adaptation.

Tags

Engineering Self-Adaptive Systems through Feedback Loops

Reference: Brun, Y., Di Marzo Serugendo, G., Gacek, C., Giese, H., Kienle, H., Litoiu, M., Müller, H., Pezzè, M. & Shaw, M. (2009). Engineering Self-Adaptive Systems through Feedback Loops. In Software Engineering for Self-Adaptive Systems, LNCS 5525, Springer, pp. 48–70. DOI: 10.1007/978-3-642-02161-9_3. URL

Summary

This chapter makes a single, influential argument: the feedback loop should be a first-class, explicit entity in the engineering of self-adaptive software. The authors observe that although virtually every self-adaptive system is, at heart, one or more control loops, those loops are usually hidden — dispersed through the code and left implicit — which makes the system hard to understand, analyse, and assure. Their prescription is to surface the loop as an architectural element with named, documented parts, drawing directly on the long tradition of control engineering, where feedback loops are the primary object of design and analysis.

The paper anatomises the loop into its canonical activities — collect (sense), analyse, decide, and act — closely mirroring MAPE-K, and stresses the properties engineers must reason about by analogy to control theory: stability, accuracy, settling time, and overshoot, together with the handling of disturbances and the cost of sensing and actuation. It further argues for making the loop’s control properties explicit design concerns and for recognising when a system needs multiple, possibly interacting or hierarchical loops. By naming the feedback loop as the unit of design and importing control-theoretic vocabulary, the chapter became a standard reference for the “the loop is the architecture” stance in self-adaptive systems.

Key Ideas

Make the feedback loop first-class: name it, document its parts, and treat it as the primary architectural element — not logic buried in code.
Canonical loop activities — collect → analyse → decide → act — align with the MAPE-K phases.
Import control-engineering properties as design concerns: stability, accuracy, settling time, overshoot, disturbance rejection.
Reason explicitly about multiple and interacting loops (hierarchical or coordinated control).
Positions control theory as a source of both design guidance and assurance for adaptation.

Connections

Conceptual Contribution

Claim: Because a self-adaptive system is a feedback control system, the feedback loop should be an explicit, first-class engineering artefact whose control properties are designed and analysed, not an implicit by-product of the code.
Mechanism: Surface the loop as an architectural element with named collect/analyse/decide/act parts (the MAPE-K phases), reason about it with control-theoretic properties (stability, accuracy, settling time, overshoot), and structure systems as one or more coordinated loops.
Concepts introduced/used: Feedback Loop, MAPE-K, Control Theory, Self-Adaptation
Stance: engineering / position
Relates to: Deepens the feedback-loop theme of the SEAMS roadmaps (Software Engineering for Self-Adaptive Systems - A Research Roadmap); its control-theoretic programme is made rigorous in Feedback Control of Computing Systems and Automated Design of Self-Adaptive Software with Control-Theoretical Formal Guarantees.

Tags

Self-Adaptive Software - Landscape and Research Challenges

Self-Adaptive Software: Landscape and Research Challenges

Reference: Salehie, M. & Tahvildari, L. (2009). Self-Adaptive Software: Landscape and Research Challenges. ACM Transactions on Autonomous and Adaptive Systems (TAAS) 4(2), Article 14. DOI: 10.1145/1516533.1516538. URL

Summary

This survey organises the self-adaptive-software field into a coherent taxonomy and a research roadmap. Its recurring analytic device is a set of “self-*” questions derived from the classic journalistic hexad — where, what, when, why, who, how — used to structure both what a system adapts and how it is built. The authors position self-adaptation against the neighbouring traditions of Autonomic Computing, multi-agent systems, control theory, and machine learning, and distil their shared structure into an adaptation feedback loop of the MAPE-K form.

On what and where, the survey classifies adaptation by the properties being maintained — the self- properties* (self-configuring, self-healing, self-optimising, self-protecting, and the enabling self-awareness/self-monitoring) — and by the artefacts and layers where change is applied. On when, it distinguishes reactive from proactive adaptation and static from dynamic decision-making. On how, it surveys the mechanisms of monitoring, detecting, deciding, and acting, together with the models and knowledge each phase needs.

The paper’s lasting contribution is as a map and vocabulary: it fixes the terminology (adaptation properties, the MAPE-style loop, the object and level of adaptation) that later work builds on, and it enumerates the open research challenges — engineering trustworthy adaptation, assurance and verification, handling uncertainty, and decentralised/large-scale control — that motivate much of the subsequent SEAMS-community literature.

Key Ideas

A taxonomy via the six “self-*” questions (where/what/when/why/who/how) spanning object, level, timing, and mechanism of adaptation.
Self- properties* organised into a hierarchy: general (self-managing), major (configuring/healing/optimising/protecting), and enabling (self-awareness/self-monitoring).
Adaptation loop cast in MAPE-K terms as the common structure across autonomic computing, control theory, and agents.
Reactive vs. proactive and static vs. dynamic decision-making as key design axes.
A research roadmap: assurance/verification of adaptation, dealing with uncertainty, trust, and scale/decentralisation.

Connections

Conceptual Contribution

Claim: The self-adaptive-software field can be organised by asking, of any adaptation, where/what/when/why/who/how — yielding a taxonomy of adaptation properties, objects, timing, and mechanisms that unifies autonomic computing, control theory, and agent-based approaches under a common feedback-loop structure.
Mechanism: A survey framework built on the six self-* questions and a hierarchy of self-* properties, mapped onto a MAPE-style adaptation loop, used to classify existing systems and to expose gaps (assurance, uncertainty, trust, scale).
Concepts introduced/used: Self-Adaptation, MAPE-K, Adaptation Dimensions, Self-* Properties, Assurance
Stance: survey / taxonomy
Relates to: The standard map for the cluster anchored by The Vision of Autonomic Computing; classifies architecture-based approaches like Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure and reference models like Self-Managed Systems - an Architectural Challenge, and shares its property vocabulary with the ensemble-oriented Self-Adaptation Self-Expression Self-Awareness ASCENS.

Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure

Rainbow: Architecture-Based Self-Adaptation with Reusable Infrastructure

Reference: Garlan, D., Cheng, S.-W., Huang, A.-C., Schmerl, B. & Steenkiste, P. (2004). Rainbow: Architecture-Based Self-Adaptation with Reusable Infrastructure. IEEE Computer 37(10): 46–54. DOI: 10.1109/MC.2004.175. URL

Summary

Rainbow is a framework for adding self-adaptation to existing systems by using an architectural model of the target system as the basis for monitoring, problem detection, and repair. Its core claim is that a software architecture — components, connectors, and properties — is the right level of abstraction for reasoning about system-wide adaptation: it is abstract enough to be tractable and to express global constraints (latency, cost, availability), yet concrete enough to map to real system elements. This is a concrete realisation of the MAPE-K loop where the architecture is the runtime model (see Models@run.time).

The framework provides a reusable infrastructure with clearly separated, customisable parts. Probes instrument the running system; gauges aggregate probe readings into updates on the architectural model; a model manager maintains the architecture; a constraint evaluator checks the model against invariants and triggers adaptation when they are violated; and an adaptation engine selects and carries out repairs through system-level effectors. Rainbow separates this generic machinery from a system-specific adaptation knowledge layer — the architectural style, constraints, and repair strategies — so the same infrastructure can be retargeted to different systems at much lower cost than bespoke, code-level adaptation.

Rainbow’s key engineering contribution is thus reuse: rather than weaving adaptation logic into application code, developers supply an architectural model, a set of constraints, and a library of repair strategies, and the shared infrastructure supplies the control loop. The approach is later extended with utility-based strategy selection and the Stitch adaptation language, and exercised on canonical exemplars such as the Znn.com news-service testbed, which together made Rainbow the reference example of architecture-based self-adaptation.

Key Ideas

Architecture as the locus of adaptation: reason about the system through its component-and-connector model, not its source.
Reusable control-loop infrastructure: probes, gauges, model manager, constraint evaluator, adaptation engine, effectors.
Separation of generic mechanism from system-specific adaptation knowledge (style, constraints, strategies) — the source of reuse and low retargeting cost.
Constraint-triggered repair: violated architectural invariants drive selection of a repair strategy.
Externalised adaptation: the adaptation logic lives outside the target system, keeping the application unchanged.
Later refinements: utility-based strategy selection and the Stitch strategy language; Znn.com as the standard testbed.

Connections

Conceptual Contribution

Claim: Self-adaptation should be engineered at the architectural level using a reusable framework: a runtime model of the system’s architecture, plus system-specific constraints and repair strategies, lets the same adaptation infrastructure be retargeted across systems instead of hand-coded each time.
Mechanism: Probes instrument the system; gauges update an architectural model; a constraint evaluator detects invariant violations; an adaptation engine selects repair strategies and enacts them via effectors — a MAPE-K loop over an architectural runtime model, with generic infrastructure cleanly separated from a customisable adaptation-knowledge layer.
Concepts introduced/used: Architecture-Based Adaptation, MAPE-K, Models@run.time, Software Architecture, Constraint Evaluation, Utility Function
Stance: engineering / framework
Relates to: The canonical architecture-based exemplar of The Vision of Autonomic Computing; complements the layered separation of concerns in Self-Managed Systems - an Architectural Challenge and sits inside the taxonomy of Self-Adaptive Software - Landscape and Research Challenges. Its “architecture as formal artefact” stance rhymes with pattern-based dependability in Architectural Patterns for Dependable Software Systems - SOL.

An Architecture-Based Approach to Self-Adaptive Software

Reference: Oreizy, P., Gorlick, M. M., Taylor, R. N., Heimbigner, D., Johnson, G., Medvidovic, N., Quilici, A., Rosenblum, D. S. & Wolf, A. L. (1999). An Architecture-Based Approach to Self-Adaptive Software. IEEE Intelligent Systems 14(3): 54–62. DOI: 10.1109/5254.769885. URL

Summary

This paper is one of the founding statements of architecture-based self-adaptation, arguing — several years before the MAPE-K vocabulary crystallised — that self-adaptive software should be organised around an explicit model of its own software architecture. Rather than scattering adaptation logic through application code, the authors propose using the architectural description (components, connectors, configurations) as the artefact that is monitored, reasoned about, and modified at runtime. Keeping the architecture “in the loop” gives adaptation a principled, system-wide handle: global properties and constraints can be stated and checked at the architectural level, and change can be expressed as reconfiguration of the component-and-connector graph.

The paper decomposes self-adaptation into two intertwined processes. Adaptation management is the outer control activity — evaluating the running system, deciding when and how to change it, and enacting the change while preserving consistency and integrity. Evolution management maintains the architectural model itself and mediates all runtime modifications so that the implementation and its architectural description stay consistent. The authors frame the hard problems as when to adapt, what to change, and how to make the change safely (open questions of validity, ordering, and state transfer during dynamic reconfiguration). They ground the discussion in their work on the C2 architectural style and the ArchStudio/dynamic-reconfiguration tooling built around it.

Key Ideas

Architecture as the basis for adaptation: make the component-and-connector model a first-class, runtime-manipulable artefact, not just a design document.
Two processes: adaptation management (observe → decide → enact change) and evolution management (keep the architectural model and the running implementation consistent).
Dynamic reconfiguration as the mechanism of change: add, remove, replace, and rewire components at runtime under architectural constraints.
Central open questions: when to adapt, what to adapt, and how to adapt safely (consistency, integrity, state transfer, quiescence).
Grounded in the C2 style and explicit architectural modelling; a direct ancestor of later frameworks like Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure.

Connections

Conceptual Contribution

Claim: Self-adaptive software is best engineered around an explicit, runtime-accessible model of its own architecture, so that adaptation is reasoned about and enacted as principled reconfiguration of components and connectors rather than as ad hoc code changes.
Mechanism: Split the system into an adaptation-management loop that decides when/what/how to change and an evolution-management layer that keeps the architectural model causally connected to the running implementation, enacting change through dynamic reconfiguration under architectural constraints.
Concepts introduced/used: Architecture-Based Adaptation, Software Architecture, Models@run.time, Dynamic Reconfiguration, MAPE-K
Stance: engineering / position
Relates to: The direct architectural ancestor of Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure and the layered separation in Self-Managed Systems - an Architectural Challenge; predates but anticipates the runtime-model idea later named Models@run.time, and sits inside the taxonomy of Self-Adaptive Software - Landscape and Research Challenges.

Tags

The Vision of Autonomic Computing

Reference: Kephart, J. O. & Chess, D. M. (2003). The Vision of Autonomic Computing. IEEE Computer 36(1): 41–50. DOI: 10.1109/MC.2003.1160055. URL

Summary

This manifesto argues that the chief obstacle to further progress in computing is not raw capability but complexity: the installation, configuration, tuning, and maintenance of large heterogeneous systems is outstripping the ability of human administrators to manage them. Taking the human autonomic nervous system as its metaphor — it regulates heartbeat and temperature without conscious attention — the paper proposes autonomic computing: systems that manage themselves against high-level objectives supplied by administrators, who say what is wanted rather than how to achieve it.

The paper’s central architectural abstraction is the autonomic element: an autonomic manager wrapping a managed element, coupled to it through sensors and effectors, and running a closed control loop. That loop — Monitor, Analyse, Plan, Execute over a shared Knowledge base — is the MAPE-K loop that became the field’s organising pattern. Autonomic elements are composed into larger systems whose global self-management emerges from local manager behaviour and inter-element relationships (service agreements, negotiation).

Kephart and Chess frame the field’s goals through four self- properties*: self-configuration (systems configure themselves from high-level policy), self-healing (detect, diagnose, and repair faults), self-optimisation (continually tune performance and resource use), and self-protection (defend against and anticipate attacks). They lay out a research agenda spanning the individual-element level (theory of autonomic elements, lifecycle, learning) and the system level (emergent behaviour, negotiation, trust, and the engineering and assurance challenges of large adaptive systems).

Key Ideas

Complexity is the limiting factor; the answer is systems that manage themselves given high-level goals.
Autonomic element = autonomic manager + managed element, joined by sensors and effectors.
MAPE-K control loop: Monitor → Analyse → Plan → Execute over shared Knowledge.
Self-CHOP properties: self-configuration, self-healing, self-optimisation, self-protection.
Policy-based, goal-directed management: administrators specify objectives, not procedures.
System-level self-management as emergent from many interacting autonomic elements (agreements, negotiation, trust).
A broad research agenda naming learning, optimisation, negotiation, and assurance as open problems.

Connections

Conceptual Contribution

Claim: As systems outgrow human administrability, they must become self-managing — regulating their own configuration, health, performance, and defence against high-level objectives rather than step-by-step instructions.
Mechanism: Wrap each managed element in an autonomic manager that runs a Monitor–Analyse–Plan–Execute loop over a shared Knowledge base (MAPE-K), reading sensors and driving effectors; compose autonomic elements, coordinated by service agreements and negotiation, into self-managing systems judged by the self-CHOP properties.
Concepts introduced/used: Autonomic Computing, MAPE-K, Self-Adaptation, Feedback Loop, Models@run.time
Stance: vision / research agenda
Relates to: The origin point for the self-adaptive cluster — the architecture-based realisation in Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure, the reference architecture of Self-Managed Systems - an Architectural Challenge, and the taxonomy of Self-Adaptive Software - Landscape and Research Challenges all build on this framing. The biological metaphor complements the biology-inspired adaptation in Self-Adaptation Self-Expression Self-Awareness ASCENS.

MAPE-K

In this vault

Related

Backlinks