---
title: Hierarchical Reflection Architecture
url: https://www.emergentmind.com/topics/hierarchical-reflection-architecture
type: topic
---

# Hierarchical Reflection Architecture

Searching arXiv for recent papers directly related to “hierarchical reflection architecture” and adjacent formulations of hierarchical reflection across agents, software architecture, and formal systems.
Hierarchical Reflection Architecture denotes a class of architectures in which reflection is organized explicitly across multiple levels of abstraction, scope, or temporal scale, rather than being treated as a single undifferentiated self-monitoring mechanism. Across the literature, the term does not refer to one universally standardized formalism; instead, it appears in several technically distinct but structurally analogous settings, including single-image reflection removal, LLM and MLLM agents, software architecture recovery, runtime reflection in semantic towers, hierarchical execution in cognitive architectures, and formal logics of layered refinement. In these settings, the common pattern is a layered organization in which higher or broader levels monitor, reinterpret, constrain, or refine lower or narrower levels, often with explicit mechanisms for cross-level propagation, decomposition, and reconstruction [2506.05489], [2507.16853], [2509.12810], [2606.04034].

## 1. Conceptual scope and defining properties

A hierarchical reflection architecture is characterized by the coexistence of at least two structurally distinct levels at which a system represents, evaluates, or transforms its own operation. The hierarchy may be spatial, temporal, semantic, architectural, or logical, depending on domain. In single-image reflection removal, the hierarchy is spatial and representational: encoder–decoder levels, hierarchical attention windows, and dual spatial–frequency branches jointly model reflections across scales and domains [2506.05489]. In mobile GUI agents, the hierarchy is temporal: action-level, trajectory-level, and global task-level reflectors detect and correct errors at progressively broader horizons [2507.16853]. In multi-task LLM agents, the hierarchy is mnemonic: high-level planning memory is separated from low-level execution memory, and hindsight reflection populates both levels with reusable knowledge [2509.12810].

A second defining property is explicit cross-level linkage. In ROS 2 architecture recovery, `AtomicRosNodeClassifier`, `ComposedRosNodeClassifier`, and `RosNodePart` encode a hierarchical structural decomposition in which node instances are typed by either atomic or composed classifiers, and launch-file inclusion induces nested subsystem structure [2605.20055]. In k-layered transition systems, the compatibility predicate \(D^n\) constrains which tuples \((w_0,\dots,w_k)\) constitute valid cross-layer configurations, and transition relations \(R_k\) act over these tuples rather than over isolated states [1606.02019]. In runtime semantic towers, safe-point subsets \(O \subseteq C.o\) and partial interpretation functors \(\Phi : O \to A\) define when a more concrete computation can be observed at a more abstract level [2606.04034].

A third recurring property is reflection-driven adaptation. In agentic systems, reflection modules generate corrective feedback or reusable experience. In architectural systems, reflection enables reconstruction or evolution of structure. In formal settings, reflection principles increase deductive strength or refine behavioral specifications. This suggests a general interpretation: a hierarchical reflection architecture is not merely layered representation, but layered self-reference with operational consequences.

## 2. Image restoration interpretation: hierarchical modeling of reflection phenomena

In single-image reflection removal, the term acquires a particularly concrete computational meaning through the F2T2-HiT architecture for SIRR [2506.05489]. The problem is posed as decomposing an observed image \(I\) into transmission and reflection layers,
\[
I = T + R \quad\text{with the goal that}\quad T \approx B,
\]
where \(B\) is the ground-truth reflection-free image. The motivating claim is that real reflections are highly heterogeneous in intensity, shape and structure, light source, spatial scale, and image coverage, making reflection removal intrinsically multi-scale and context-dependent [2506.05489].

The architecture realizes hierarchy at three distinct levels. First, it uses a U-shaped encoder–decoder structure akin to UNet/NAFNet, yielding a spatial multi-scale hierarchy from shallow, high-resolution detail to low-resolution global context. Second, it incorporates Hierarchical Transformer (HiT) blocks with window sizes \(4\times4\), \(8\times8\), and \(16\times16\), providing hierarchical attention within each feature level. Third, it includes FFT Transformer (F2T2) blocks that combine a spatial-domain branch and a frequency-domain branch, creating a domain hierarchy between local spatial cues and global frequency structure [2506.05489].

The frequency branch applies a 2D FFT channel-wise,
\[
X_f = \mathcal{F}(X),
\]
followed by learnable modulation,
\[
\tilde{X}_f = W_f \odot X_f, \qquad \tilde{X}_g = \mathcal{F}^{-1}(\tilde{X}_f),
\]
while the spatial branch produces \(X_s\) through multi-kernel depthwise convolutions. A typical fusion form is
\[
Y = X_s + \tilde{X}_g.
\]
This arrangement gives the model image-wide receptive fields via FFT while preserving local texture and boundary structure through spatial processing [2506.05489].

The HiT block retains a Transformer-like outer structure but performs hierarchical window-based attention. For a windowed feature tensor \(X\), standard projections
\[
Q = XW_Q,\quad K = XW_K,\quad V = XW_V
\]
are used conceptually, while spatial-scale correlation and channel-scale correlation are aggregated with linear complexity relative to window size. This allows large windows without quadratic self-attention cost [2506.05489].

Empirically, the full model “NAFNet+HiT+F2T2” attains an average PSNR of **25.57 dB** and **SSIM 0.894**, compared with **23.97 dB / 0.882** for the NAFNet baseline, **24.78 dB / 0.888** for “NAFNet+Restormer,” and **25.00 dB / 0.891** for “NAFNet+HiT” [2506.05489]. On SIR² it achieves **25.72 dB / 0.903 SSIM**. These results support the interpretation that a hierarchical reflection architecture in image restoration is one that models reflection artifacts across spatial resolution, attention scope, and frequency structure simultaneously.

This suggests a domain-specific definition: in restoration, a hierarchical reflection architecture is a system that assigns reflection versus transmission responsibility through layered decomposition across multiple representational domains.

## 3. Multi-agent and LLM systems: temporal and mnemonic hierarchies of self-correction

In LLM- and MLLM-based agents, hierarchical reflection refers primarily to reflection organized over temporal scope or memory granularity. The MobileUse GUI agent provides a canonical temporal formulation [2507.16853]. Reflection is partitioned into three levels: action-level feedback \(r_a^t\), trajectory-level feedback \(r_t^t\), and global/task-level feedback \(r_g^t\), with
\[
r^t = (r_a^t, r_t^t, r_g^t).
\]
The Operator generates
\[
a^t = (a_t^t, a_a^t, a_d^t) = O(I, K_I, s^t, a^{:t-1}, r^{t-1}, p^{t-1}),
\]
and the Progressor updates
\[
p^t = P(a^{:t-1}, p^{t-1}, a^t, r^t).
\]
Action Reflection is invoked selectively via a confidence score over action-type tokens,
\[
\hat{c}^t = \frac{1}{k}\sum_{i=1}^{k}\log p(w_i),
\]
with reflection triggered when \(\hat{c}^t \le \theta\) [2507.16853].

The three reflective levels serve distinct functions. The Action Reflector checks whether a single action caused the intended local screen change. The Trajectory Reflector detects loops, repeated screenshots, and accumulated local errors over recent steps. The Global Reflector verifies whether the entire instruction has actually been fulfilled when the agent proposes termination [2507.16853]. This produces a temporally stratified reflective control loop in which local corrections do not require immediate global replanning, while premature task completion can still be vetoed.

The quantitative effect is substantial. On AndroidWorld, the base system without reflection or exploration achieves **49.5** average success rate, while adding Action Reflector increases it to **55.17**, Trajectory Reflector to **56.1**, Global Reflector to **58.6**, and Reflection-on-Demand to **61.6**; adding Proactive Exploration then yields **62.9** [2507.16853]. On AndroidLab, MobileUse attains **44.20%** SR and **50.01%** Sub-SR [2507.16853]. Reflection corrects **18** previously failed tasks, corresponding to a **30.51% correction rate**, while misjudging **7.02%** of successful tasks [2507.16853].

A related but more memory-centric formulation appears in H\(^2\)R for multi-task LLM agents [2509.12810]. Here the hierarchy separates high-level planning memory
\[
\mathcal{M}_{\mathrm{high}} = \{(\mathcal{X}^i,\mathcal{G}_+^i,\mathcal{I}_{\mathrm{high}}^i)\}
\]
from low-level execution memory
\[
\mathcal{M}_{\mathrm{low}} = \{(g^i,\tau_+^i,\mathcal{I}_{\mathrm{low}}^i)\}.
\]
Hindsight reflection infers subgoals,
\[
\mathcal{G}^i \leftarrow \mathcal{F}_{\text{subgoal}}(\mathcal{X}^i,\tau^i),
\]
extracts high-level planning insights and low-level execution insights, and grounds them back into separate memory stores [2509.12810]. At test time, high-level retrieval is conditioned on task description \(\mathcal{X}\), whereas low-level retrieval is conditioned on the current subgoal \(g\).

This decoupling yields measurable gains. On AlfWorld, H\(^2\)R improves success from **72.4%** for ExpeL to **75.9%**; on PDDLGame it improves from **72.2%** to **80.5%** [2509.12810]. Ablation shows that removing high-level memories drops PDDLGame success to **52.8%**, while removing low-level memories drops it to **61.1%** [2509.12810]. A plausible implication is that hierarchical reflection in LLM agents is most effective when reflective knowledge is stored and retrieved at the same granularity at which decisions are made.

MA-CoNav extends this logic into embodied VLN with both organizational and reflective hierarchy [2603.03024]. It adopts a “1 Master + 4 Sub-agents” structure—Task Planning Agent, Observation Agent, Control Execution Agent, and Memory Agent—plus a “Local-Global” dual-stage reflection mechanism [2603.03024]. Local reflection evaluates candidate actions against immediate obstacles and risk patterns from memory:
\[
\text{flag}_{\text{local}} = R_{\text{local}}(a_t, O_t, M_t, s_{\text{current}}),
\]
whereas global reflection segments full histories \(H\) into episodes, diagnoses failures, and stores structured experience tuples
\[
e_k = \langle \text{ID}_k, F_k, T_k, I_k \rangle, \qquad I_k=(F_{\text{err}}, a_{\text{err}}, \text{cause}, a_{\text{corr}}).
\]
On a real-world indoor dataset, MA-CoNav reaches **SR = 25.6%**, compared with **8.4%** for RCTAMP and **2.8%** for CoELA; removing the reflection mechanism reduces SR to **17.2%** [2603.03024]. Here reflection is hierarchical both by temporal scope and by control authority.

## 4. Software and runtime systems: architecture as reflected structure

In software architecture research, hierarchical reflection architecture often denotes explicit multi-level structural representation plus mechanisms for reconstruction, evolution, or runtime ascent.

The ROS 2 architecture recovery pipeline in [2605.20055] uses a UML-based modeling concept with `AtomicRosNodeClassifier`, `ComposedRosNodeClassifier`, and `RosNodePart`. The hierarchy distinguishes source-level node definitions from launch-level instantiation and subsystem composition. The architecture is reconstructed through a staged, agent-based pipeline comprising NodeAnalyzer, ComponentArchitectureTeam, LaunchFileAnalyzer, and SystemArchitectureTeam. Two intermediate representations are central: the **List of Atomic ROS Nodes (JSON)** and the **Launch File Dependency Description (JSON)** [2605.20055]. These constrain reconstruction across multiple abstraction levels and yield both `AtomicClassifierDiagram (ACD)` and `ComposedClassifierDiagram (CCD)` models.

In evaluation on the BrickByBrick case study, ACD recovery achieves **Precision = 1.0**, **Recall = 1.0**, **F1 = 1.0**, while CCD recovery achieves **Precision = 1.0**, **Recall = 0.95**, **F1 = 0.98** [2605.20055]. The architecture is reflective in the sense that it can be re-derived from distributed implementation artifacts and linked back to them via IDs, launch-file dependencies, and namespace scopes. This suggests an architectural definition of hierarchical reflection: a system in which implementation evidence can regenerate nested architectural views with traceable links across levels.

A more explicit runtime formulation appears in “Climbing Up the Semantic Tower -- at Runtime” [2606.04034]. Software is modeled as a semantic tower of implementations. A concrete language or machine \(C\) implements a more abstract one \(A\) via a subset \(O \subseteq C.o\) of observable safe points and an interpretation functor
\[
\Phi : O \to A.
\]
Reflection is not limited to descending into lower-level runtime states; rather, safe points allow a running concrete computation to be observed at a higher abstraction level. The paper formalizes observability with an `observe` function whose computational content ensures that any interrupted concrete execution fragment can be extended to a safe point and mapped to an abstract transition [2606.04034]. Implementations become first-class values, enabling migration between implementations while execution continues.

This runtime tower is hierarchical because each level implements the one above and can itself be reflected upon. It is reflective because the implementation relation is exposed as a usable protocol rather than hidden beneath compilation boundaries.

The ArchWare ADL work provides a complementary structural view [1006.4740]. Active software architectures are defined as dynamic, updatable, decomposable, and reflective. Key mechanisms include `compose`, `decompose`, hyper-code, and the maps
\[
\mathit{reflect} : R \to E, \qquad \mathit{reify} : E \to R,
\]
with \(E\) the domain of entities and \(R\) the domain of representations [1006.4740]. A running system can be decomposed into components, reified into hyper-code, transformed, reflected back, and recomposed. Because a composed behavior is itself a behavior, composition induces an implicit hierarchy of subsystems. Reflection therefore operates structurally over nested compositions.

The earlier thesis on reflection and hyper-programming in persistent systems further clarifies this layering [1006.3481]. It describes a stack comprising the persistent store and runtime, linguistic reflection mechanisms, hyper-programming, and reflective tools over hyper-program representations. The key abstract decomposition of evaluation into `compile`, `eval'`, `drop`, and `raise` provides a phase hierarchy—composition time, compile time, link time, run time—while hyper-programs add a representation layer in which source contains direct links into the persistent store [1006.3481]. This work does not use the phrase “hierarchical reflection architecture,” but it provides a precise instance of one.

## 5. Formal and logical formulations

A formal semantics of hierarchical reflection appears in the logic of n-dimensional hierarchical refinement [1606.02019]. An \(n\)-layered model is
\[
M=(W^n,D^n,R^n,V^n),
\]
where \(W_k\) is the set of local states at level \(k\), \(D^n \subseteq W_0 \times \cdots \times W_n\) is the compatibility predicate, \(R_k \subseteq D_k \times D_k\) are level-specific transition relations, and valuations for propositions and nominals depend on level [1606.02019]. A hierarchical model satisfies
\[
R_k|_{k-1} = R_{k-1},
\]
meaning projection of a \(k\)-transition to lower layers recovers the lower-layer transition structure exactly [1606.02019].

This framework supports formulas at multiple levels, including modal operators \(\Diamond_k\) and satisfaction operators \( @_{i_k}\), and provides standard translation into many-sorted first-order logic. Reflection here is not operational self-critique but layered self-description: higher levels encode abstractions of lower levels, and refinement adds new layers while preserving positive properties under simulation [1606.02019]. Bisimulation and simulation are defined over compatible tuples rather than isolated states, which makes the hierarchy semantically first-class.

A distinct but philosophically related use of reflection appears in proof theory [1405.2558]. Reflection principles over PA include local reflection
\[
\Box P \to P
\]
and mixed explicit–implicit reflection
\[
\Box^k(u:P)\to P.
\]
The paper proves that every such reflection principle is equivalent either to \(\Box P \to P\) or to \(\Box^k(u:P)\to P\) for some \(k \ge 0\), and that they form a strict hierarchy
\[
u:P\to P \;<\; \Box(u:P)\to P \;<\; \Box^2(u:P)\to P \;<\; \dots \;<\; \Box P\to P
\]
[1405.2558]. This is a logical hierarchy of self-trust or self-recognition rather than an implemented architecture, but it shows that hierarchical reflection can be formalized as non-collapsing levels of increasingly strong self-referential principles.

This suggests a broader interpretation: formal hierarchical reflection requires not merely multiple levels, but nontrivial cross-level semantics that preserve distinctions in strength or expressivity.

## 6. Cross-domain synthesis, design patterns, and recurrent tensions

Across these disparate domains, several recurring design patterns emerge.

One is **coarse-to-fine organization**. F2T2-HiT processes reflections from shallow high-resolution detail to low-resolution global context, while HiT further spans window sizes \(4, 8, 16\) [2506.05489]. MobileUse escalates from action-level to trajectory-level to global-level reflection [2507.16853]. TimeSearch for long-video understanding, although framed around Spotlight and Reflection rather than the exact phrase “hierarchical reflection architecture,” applies reflection-guided best-first search over temporal segments, combining global sparse context, recursive event subdivision, and final dense spotlighting [2504.01407]. MA-CoNav similarly separates step-level correction from episode-level reflective knowledge construction [2603.03024].

A second pattern is **separation of representation and control levels**. In software systems, higher architectural levels reconstruct or manipulate lower-level structure rather than directly executing their logic [2605.20055], [1006.4740], [2606.04034]. In H\(^2\)R, planning memory and execution memory are not merely two retrieval pools; they correspond to distinct decision strata [2509.12810]. In hierarchical transition systems, higher-level states are refined into local transition systems while preserving projection consistency [1606.02019].

A third pattern is **explicit traceability across levels**. ROS 2 recovery uses IDs, typing relations, and launch inclusions [2605.20055]. Semantic towers use safe points and interpretation functors [2606.04034]. Hyper-programming stores source with links into the persistent store [1006.3481]. Without such traceability, hierarchy becomes descriptive rather than reflective.

A fourth pattern is **reflection as selective intervention rather than universal recomputation**. MobileUse invokes Action Reflection only when \(\hat{c}^t \le \theta\), showing that selective reflection can improve both efficiency and performance [2507.16853]. TimeSearch uses reflection confidence to prioritize temporal search and stop early when confidence exceeds \(\epsilon\) [2504.01407]. Dynamic Hierarchical Justification in Soar-like hierarchical execution uses subtask support sets to retract entire subtasks when higher-level assumptions change, rather than maintaining fine-grained justifications for each assumption [1106.4871]. This suggests that hierarchy often serves not only representational richness but computational tractability.

The main recurring tension is between **granularity and cost**. Finer-grained reflection can improve correction or reuse, but may increase complexity, latency, or instability. MobileUse shows that reflecting at every step is not optimal; confidence-based triggering performs better [2507.16853]. H\(^2\)R shows that flat memory is too coarse, but hierarchical decomposition requires extra subgoal inference and segmentation machinery [2509.12810]. In DHJ, subtask-level retraction is simpler than assumption-level retraction but can cause unnecessary regeneration [1106.4871]. In runtime semantic towers, observability requires semantically defined safe points, which may impose implementation constraints [2606.04034].

Another tension concerns **static versus dynamic hierarchy**. F2T2-HiT uses fixed window sizes and fixed encoder–decoder scales [2506.05489]. MA-CoNav’s local–global reflection is architecturally fixed [2603.03024]. ROS 2 recovery currently relies on static launch-file evidence and struggles with dynamic integration semantics [2605.20055]. Several works therefore imply future directions toward content-adaptive scale selection, dynamic windowing, richer runtime evidence, or online evolution of reflective structure.

## 7. Limitations, misconceptions, and prospective directions

A common misconception is that hierarchical reflection architecture always means a meta-controller supervising lower-level modules. The literature shows a broader range. In image restoration, it may instead mean multi-scale and multi-domain decomposition of a phenomenon called “reflection” [2506.05489]. In proof theory, it refers to stratified self-referential principles of provability [1405.2558]. In formal system design, it may denote tower navigation across abstraction levels [2606.04034] or hierarchical refinement semantics [1606.02019]. The unifying feature is layered self-relation, not any one implementation pattern.

Another misconception is that hierarchy automatically implies improved robustness. The evidence is more specific. Gains appear when hierarchy aligns with task structure: reflection size diversity in SIRR [2506.05489], temporal scale in GUI control [2507.16853], subgoal decomposition in LLM agents [2509.12810], or launch-induced structure in ROS 2 systems [2605.20055]. Misaligned hierarchies may simply add complexity.

Several limitations recur across the surveyed work. Static reflective structures often struggle with dynamic conditions, as noted for ROS 2 launch semantics [2605.20055] and fixed windowing or scale choices in SIRR [2506.05489]. Reflection quality often depends on the quality of the underlying model, as seen in LLM-based self-reflection systems where critiques may hallucinate or misjudge states [2507.16853], [2509.12810]. Post-hoc reflective knowledge may improve reuse but not guarantee online adaptation, since many systems update memory offline or episodically rather than continuously [2509.12810], [2603.03024].

Prominent future directions are already visible in the cited work. In image restoration, plausible extensions include dynamic scale selection, content-adaptive windowing, more structured frequency priors, explicit prediction of both \(T\) and \(R\), and temporal extensions for video reflection removal [2506.05489]. In agent systems, likely continuations include richer multi-scale reflection triggers, tighter integration of memory and planning, and extension to more complex embodied or web environments [2507.16853], [2509.12810], [2603.03024]. In software systems, major open directions include dynamic semantic integration, formalized metamodels, and first-class runtime reflection protocols deployed in real systems rather than primarily as formal blueprints [2605.20055], [2606.04034]. In formal logic and semantics, a plausible implication is that richer hierarchies of reflection could be studied by combining layered transition semantics, explicit proof formalisms, and operational reflection mechanisms [1606.02019], [1405.2558].

Taken together, the literature supports a domain-general characterization: a hierarchical reflection architecture is a structured arrangement in which reflection is distributed across explicitly related levels, with each level operating on representations appropriate to its scope and feeding corrections, abstractions, or reconstructions across levels. What varies from field to field is the substrate—pixels, trajectories, memories, launch files, transition systems, proofs, or runtime states—but the architectural motif remains strikingly consistent.

Source: https://www.emergentmind.com/topics/hierarchical-reflection-architecture