---
title: AMER in Microservices & Retrieval
url: https://www.emergentmind.com/topics/amer
type: topic
---

# AMER in Microservices & Retrieval

AMER is an acronym used in recent arXiv literature for two distinct systems with unrelated application domains. In microservice reliability engineering, AMER denotes **Agentic Memory Enhanced Recursive reasoning**, instantiated as **AMER-RCL**, a framework for root cause localization in complex microservice systems that combines recursive, multi-dimensional, cross-modal reasoning with cross-alert reuse of prior reasoning [2601.02732]. In dense information retrieval, AMER denotes the **Autoregressive Multi-Embedding Retriever**, a retrieval architecture that autoregressively generates multiple query embeddings for a single input query in order to capture multimodal conditional relevance distributions over documents [2511.02770]. The shared acronym therefore refers not to a single unified paradigm, but to two technically separate lines of work: one in agentic observability-driven diagnosis, and one in multi-answer dense retrieval.

## 1. Nomenclature and problem domains

The microservice-oriented usage expands AMER as **Agentic Memory Enhanced Recursive reasoning**. The corresponding framework, **AMER-RCL**, addresses **root cause localization (RCL)** in microservice systems that may contain hundreds or thousands of services, instances, pods, and hosts, where requests traverse intricate invocation chains and interact with diverse subsystems. The motivating challenges are **scale and heterogeneity**, **schema drift and evolving operational contexts**, **multi-modality of signals**, and **latency and reuse** across alerts within the same anomaly window [2601.02732].

The retrieval-oriented usage expands AMER as **Autoregressive Multi-Embedding Retriever**. It addresses the limitation of standard dense retrievers that generate a single query vector even when the conditional relevance distribution $p(d \mid q)$ is multimodal, as in ambiguous or list-style questions. The central claim is that a single embedding often becomes a compromise representation when relevant documents form multiple distant clusters in embedding space, degrading union-of-recall for top-$k$ retrieval [2511.02770].

These two meanings share only the acronym. A plausible implication is that any technical discussion of “AMER” requires domain disambiguation: in systems and SRE contexts it refers to agentic recursive diagnosis, whereas in retrieval contexts it refers to multi-query-vector generation.

## 2. AMER-RCL: formulation for root cause localization

AMER-RCL is defined as a framework that operationalizes two observations from expert SRE practice: **recursive, multi-dimensional, cross-modal reasoning**, and **efficient reuse of past reasoning across alerts**. An empirical study with **22 SREs across multiple organizations** identified three characteristics of expert RCL: **recursiveness**, **multi-dimensional expansion**, and **cross-modal reasoning** [2601.02732].

The paper formalizes classical RCL as follows. Given anomalous requests $R = \{r_1, \ldots, r_n\}$ and a component graph $G = (C, E)$, the task is to find
$$
C^* = \arg\max_{C \in \mathcal{C}} s(C, G, M)
$$
where $s(C, G, M)$ integrates graph structure and observed anomalies, and $M$ denotes multi-modal evidence such as logs and metrics. AMER-RCL instantiates $s(\cdot)$ via the **Consolidator’s synthesis of agent observations rather than a fixed parametric model**, preserving interpretability [2601.02732].

Each alert is converted into a causal graph
$$
G = (\mathcal{V}, \mathcal{E}, \mathbf{A}_v, \mathbf{A}_e).
$$
Nodes $v \in \mathcal{V}$ carry attributes
$$
a_v = (\text{service\_id}, \text{pod\_id}, \text{op\_name}, \text{metric\_summary}, \text{log\_summary}),
$$
with
$$
\text{metric\_summary}_v = [\mu_m, \sigma_m]
$$
and log summaries containing counts per log type. Edges $(u,v)\in\mathcal{E}$ represent invocations or causal dependencies with attributes
$$
a_e = (\text{call\_latency}, \text{status\_code}).
$$
These graphs serve both as keys into memory and as the substrate for recursive analysis [2601.02732].

This design directly targets the failure modes attributed to prior methods. Traditional graph-based methods rely on rigid schemas and handcrafted structures that are brittle under drift; deep learning methods are characterized as black-box and hard to transfer across deployments; and recent LLM-based systems are described as limited by **shallow, symptom-centric reasoning** and **lack of cross-alert reuse** [2601.02732].

## 3. AMER-RCL: architecture, recursive reasoning, and agentic memory

AMER-RCL consists of two tightly coupled subsystems: a **Recursive Reasoning RCL engine** and **Agentic Memory**. The engine is a multi-agent setup orchestrated by a **MetaAgent**. Specialized agents are **TraceAgent**, **LogAgent**, **MetricAgent**, and **Consolidator**. The stated functions are precise: TraceAgent retrieves relevant spans and call metadata for recursive expansion; LogAgent filters relevant logs in a time window for a target component; MetricAgent selects metrics with significant fluctuations via an **n-sigma rule**; and Consolidator synthesizes multi-modal evidence into ranked root cause outputs [2601.02732].

The retrieval and filtering primitives are formalized explicitly. TraceAgent retrieves only children of a given span $s$:
$$
T(s)=\left\{\langle t, s', svc, op, d, \sigma \rangle \;\middle|\; s' \in \mathcal{C}(s)\right\}.
$$
LogAgent filters logs for component $C$ around time $t_0$:
$$
L(t_0,\delta,C)=\left\{l \in \mathcal{L}(C)\;\middle|\; t(l)\in[t_0-\delta,t_0+\delta]\wedge \phi(l)=1\right\}.
$$
MetricAgent selects metrics satisfying
$$
|m(t)-\mu_m| > n \times \sigma_m,
$$
with
$$
Q(t_0,\delta,C)=\left\{m(t)\;\middle|\; m \in \mathcal{M}(C),\; t \in [t_0-\delta,t_0+\delta],\; |m(t)-\mu_m|>n\sigma_m\right\}.
$$
In the default implementation, **$n=3$** [2601.02732].

The recursive procedure is **depth-assured**. The paper presents the function `RecursiveRCL(s)`, beginning with `MetaAgent.GenerateInstruction(s)`, using TraceAgent for primary exploration, invoking LogAgent and MetricAgent when `MetaAgent.Suspect(s, D_t)` holds, recursively expanding suspicious children, and returning final ranked outputs through the Consolidator. Reasoning is staged as **Initial Reasoning (IR)**, **Critical Reflection (CR)**, and **Final Review (FR)**. IR withholds Metric and Log agents to expand the trace frontier rapidly; CR enforces continued recursion over suspicious spans with full agents; and FR consolidates all evidence to mitigate recency bias [2601.02732].

Agentic Memory stores, after each run,
$$
M_i = (f_i, e_i, G^{(i)}, \mathrm{meta}_i, \tau_i).
$$
Here, $f_i$ is a canonicalized graph hash, $e_i$ is a **Graph2Vec embedding**, $G^{(i)}$ is the full causal graph, $\mathrm{meta}_i$ contains metadata, and $\tau_i$ is the structured reasoning transcript. For a new alert graph, candidate entries are retrieved by nearest-neighbor search over $\{e_i\}$, followed by a combined similarity
$$
S(G^{\mathrm{new}}, G^{(i)}) = \alpha \cdot S_{\mathrm{struct}}(G^{\mathrm{new}}, G^{(i)}) + (1-\alpha)\cdot S_{\mathrm{attr}}(G^{\mathrm{new}}, G^{(i)}).
$$
Three reuse regimes are defined: direct reuse when $S \ge \tau_{\text{skip}}$, partial reuse when $\tau_{\text{partial}} \le S < \tau_{\text{skip}}$, and re-initiation when $S < \tau_{\text{partial}}$. For partial reuse, divergence nodes are
$$
\mathcal{D} = \{v \in G^{\mathrm{new}} \mid \operatorname{dist}(a_v^{\mathrm{new}}, a_v^{(i)}) > \delta\}.
$$
Memory updates follow the append rule
$$
M_{t+1} = M_t \cup \{M_i\},
$$
and the paper explicitly states that it **does not introduce decay or weighting** [2601.02732].

## 4. AMER-RCL: implementation, datasets, and empirical behavior

The default LLM backbone in AMER-RCL is **Claude-3.5 Sonnet**. Other tested backbones are **DeepSeek-R1-Qwen (Qwen2.5-32B distilled)**, **Qwen-2.5-Max**, **Qwen-2.5-Plus**, and **Llama-3.1-70B**. Alerts are processed within a fixed anomaly window of **60 seconds in experiments**, and observability integrations assume traces, logs, and metrics are available. TrainTicket deployments use **ChaosMesh** for fault injection and **Kubernetes**, whereas production datasets rely on standard tracing and monitoring stacks [2601.02732].

The evaluation uses three datasets: **AIOPS 2022**, **TrainTicket**, and **FAMOS-Mall**. Baselines include LLM-based systems (**mABC**, **RCAgent**, **CoT**) and non-LLM methods (**CRISP**, **TraceConstruct**, **TraceRCA**, **MicroRank**, **RUN**, and **Microscope**). The primary metrics are **Top-k recall (Recall@k)** and **Mean Reciprocal Rank (MRR)** [2601.02732].

The reported accuracy results are summarized below.

| Dataset | AMER-RCL result | Comparison stated in the paper |
|---|---:|---|
| AIOPS 2022 | MRR 76.30% | vs mABC 58.05% (+18.25%) and TraceRCA 42.19% (+34.11%) |
| TrainTicket | MRR 81.93% | vs mABC 67.26% (+14.67%) and TraceConstruct 54.35% (+27.58%) |
| FAMOS-Mall | MRR 75.39% | vs mABC 59.96% (+15.43%) and RCAgent 61.05% (+14.34%) |

Averaged across datasets, **AMER-RCL improves upon the second-best method (mABC) by 15.75%**. In inference speed, measured in **seconds/query**, the values are: CoT **1517.34**, **543.58**, **1401.51**; RCAgent **322.16**, **305.84**, **378.23**; mABC **2731.89**, **1490.15**, **2890.12**; and AMER-RCL **111.45**, **53.86**, **56.59** on AIOPS, TrainTicket, and FAMOS respectively. The paper summarizes this as **3.53× faster than RCAgent, 14.61× faster than CoT, and 31.05× faster than mABC on average** [2601.02732].

Ablation studies attribute distinct gains to different stages. **Initial Reasoning alone** is characterized as shallow; adding **Critical Reflection** yields average **+13.21%**; **Final Review** adds **+2.96%**; and **Agentic Memory** contributes **+2.61%**. The case study centers on a frontend timeout alert, where recursive traversal and cross-modal verification ultimately rank **RecommendationService** as the root cause, and later similar alerts are either fully reused or resumed from divergence nodes depending on the similarity regime [2601.02732].

The stated strengths are **accuracy**, **efficiency**, **robustness to schema drift and evolving contexts**, and **interpretability**. The stated limitations are **dependence on LLM quality**, **memory staleness**, **multi-modal consistency**, and **privacy/security and operational cost** [2601.02732].

## 5. AMER as Autoregressive Multi-Embedding Retriever

In retrieval, AMER is a dense retriever designed for queries whose relevant documents are distributed across multiple clusters. The motivating formalism defines a standard dense retrieval score
$$
s(q,d)=\mathrm{sim}(\mathrm{enc}_q(q), \mathrm{enc}_d(d)),
$$
typically cosine similarity. For multi-answer questions, the target set is $T(q)=\{d_1,\ldots,d_m\}$, and multimodality is quantified by the average inter-target distance
$$
\Delta(q)=\frac{2}{m(m-1)}\sum_{i<j}\mathrm{dist}(v_i,v_j),
$$
where $v_i=\mathrm{enc}_d(d_i)$ and $\mathrm{dist}$ is either cosine distance or Euclidean distance. Larger $\Delta(q)$ indicates stronger multimodality [2511.02770].

AMER is implemented as an **autoregressive language model** used as the query encoder, while the document encoder remains fixed to avoid corpus re-indexing. For an input query text $x$, the model generates multiple query embeddings autoregressively:
$$
q_t = f(x, q_{<t}; \theta).
$$
The first embedding conditions on $x$, and later embeddings condition on $x$ together with previously produced embeddings. Because the LM hidden size may differ from the document embedding dimension, the model uses input and output linear projection layers into the shared embedding space [2511.02770].

The training objective is a contrastive **InfoNCE** loss with **optimal matching over unordered targets** via the **Hungarian algorithm**. For a pair $(q,d^+)$,
$$
l(q,d^+)=-\log\left[\frac{\exp(\mathrm{sim}(q,d^+)/\tau)}{\sum_{d\in D_{\text{batch}}}\exp(\mathrm{sim}(q,d)/\tau)}\right].
$$
Because gold targets are unordered, the batch loss is
$$
\mathcal{L}_{\text{batch}} = \min_{M \in \mathfrak{M}} \sum_{(q,d^+) \in M} l(q,d^+),
$$
where $\mathfrak{M}$ is the set of matchings between generated query embeddings and gold document embeddings. Embeddings are **L2-normalized** before similarity computation. Negatives consist of **in-batch negatives** plus **one random negative paired with each positive** [2511.02770].

To mitigate train–test mismatch in autoregressive conditioning, the model uses **scheduled sampling**: with probability $1-p$ it feeds the previous gold vector, and with probability $p$ it feeds the previous predicted vector, with
$$
p=\min(0.8, \mathrm{steps\_trained}/\mathrm{total\_steps}).
$$
During inference, AMER predicts a **fixed number** $m_{\text{pred}}$ of embeddings; the paper states that **attempting variable-length stopping criteria underperformed** [2511.02770].

## 6. AMER retrieval pipeline, evaluation, and limitations

At inference time, each generated embedding $q_t$ retrieves a ranked list $D_t$ using
$$
s(q_t,d)=\cos(q_t,\mathrm{enc}_d(d)).
$$
The final top-$k$ output is assembled by **round-robin selection** across $\{D_t\}$, skipping duplicates until $k$ documents are selected. This preserves a standard single-vector document index while replacing a single query vector with multiple autoregressively generated vectors [2511.02770].

The paper evaluates AMER on both synthetic vectorized data and real-world datasets. In the synthetic setup, each query has **$m=5$ target vectors** under six conditions defined by three input distributions and two transformation types. The training set contains **20k queries**, the test set **1k**, and the corpus **200k vectors**. The reported result is that **AMER retrieves all targets perfectly (100% MRecall@10 and @100) across all settings**, whereas **Single-Query baselines never exceed 20% MRecall@10**, and on linear transformations they fail completely at **0%** due to collapse toward the average mode. The abstract summarizes this as **4× better performance than single embedding** [2511.02770].

On real-world data, the benchmarks are **AmbigQA** and **QAMPARI**. AmbigQA has **train set 5,044**, **test set 827**, and **average targets per query 2.58**. QAMPARI has **train set 32,023**, **test set 531**, and **average targets per query 6.09**. The document encoder is **Inf-Retriever (1.5B), frozen**, while query encoders include **Llama-3.2-1B/3B/8B** and **Qwen3-4B**, fine-tuned with **LoRA**. Inference uses **$m_{\text{pred}}=2$** for AmbigQA and **$m_{\text{pred}}=5$** for QAMPARI, and the principal metric is **MRecall@100** [2511.02770].

The reported macro-averaged whole-test-set gains over Single-Query baselines are **+4%** on AmbigQA and **+21%** on QAMPARI. On the **bottom 33rd percentile** low-similarity subsets, gains rise to **approximately +5%** on AmbigQA and **approximately +145%** on QAMPARI. The paper further reports that these gains are statistically significant in **6/8** whole-set backbone settings and **7/8** low-similarity subset settings using paired bootstrap tests [2511.02770].

Several analyses characterize the mechanism. Across **Contriever**, **Stella**, **Inf-Retriever**, and **NV-Embed**, performance monotonically decreases as $\Delta(q)$ increases. AMER’s outputs exhibit lower average pairwise cosine similarity than training targets for most backbones, which the paper interprets as greater output diversity. A scheduled sampling ablation shows higher gains than an **Always Predicted** training regime: **+4.18% vs. +3.41%** on AmbigQA whole, **+21.35% vs. +7.99%** on QAMPARI whole, and **+144.74% vs. +119.56%** on the QAMPARI low-similarity subset [2511.02770].

The stated limitations are **modest average gains on real datasets**, a **fixed number of embeddings**, **simple aggregation**, a **frozen document encoder and random negatives**, and the need for **broader benchmarks** where inter-target distances are explicitly large. In complexity terms, Hungarian matching has **$O(m^3)$** complexity but the paper notes that $m$ is small, while inference cost increases approximately linearly with $m_{\text{pred}}$ because AMER performs $m_{\text{pred}}$ ANN searches [2511.02770].

## 7. Comparative perspective on the two AMER systems

The two AMER systems solve different technical problems and should not be conflated. **AMER-RCL** addresses failure diagnosis in microservices by converting alerts into causal graphs, orchestrating specialized agents under a MetaAgent, and reusing prior analyses when similarity warrants it. Its core innovations are **depth-assured recursive reasoning** and **Agentic Memory** for alert-level reuse [2601.02732]. **Autoregressive Multi-Embedding Retriever** addresses multi-answer dense retrieval by generating multiple query vectors from a single text query, aligning them to unordered target modes with Hungarian-matched InfoNCE, and aggregating retrieved lists by round-robin union [2511.02770].

Their methodological contrast is equally sharp. AMER-RCL is multi-agent, cross-modal, and observability-centric; AMER retrieval is single-task, encoder-based, and embedding-centric. AMER-RCL uses traces, logs, and metrics, with causal graphs as both memory keys and reasoning substrates; retrieval AMER uses a fixed document encoder and an autoregressive query encoder, with multiple query embeddings serving as mode-specific probes into a standard single-vector ANN index. A plausible implication is that the shared acronym reflects a convergence in naming around **multi-step adaptation to heterogeneous evidence**, but not a shared algorithmic lineage.

In the microservice setting, AMER is associated with **state-of-the-art localization accuracy and practical inference efficiency** across AIOPS 2022, TrainTicket, and FAMOS-Mall. In retrieval, AMER is associated with **perfect multi-recall in synthetic multimodal settings** and **consistent gains in real-world multi-answer retrieval**, especially on low-similarity subsets. Both works frame their contribution as a response to a specific limitation of single-pass methods: shallow symptom-level reasoning in RCL, and single-vector compromise embeddings in dense retrieval [2601.02732] [2511.02770].

Source: https://www.emergentmind.com/topics/amer