Consistency Feedback Plugin (CFP)

• Consistency Feedback Plugin (CFP) is a modular mechanism that extracts semantic, visual, and attention-based signals to refine outputs and reduce hallucinations.
• CFP is applied in diverse domains, from closed-loop training in multimodal LLMs to client filtering in federated learning and architectural conformance in software systems.
• Empirical results demonstrate improved metrics such as POPE, F1, and robustness under attacks, showcasing CFP’s effectiveness in practical optimization and error mitigation.

Consistency Feedback Plugin (CFP) is not a single universally standardized artifact. In its most explicit current usage, it names a frozen reflective module inside the ReLoop closed-loop training framework for multimodal LLMs, where answer generation is fed back through semantic, visual, and attention-based consistency checks during training (Yang et al., 7 Jul 2025). Closely related plugin-style mechanisms appear in federated learning, weak-consistency verification, summarization correction, and Eclipse-based architectural conformance, where consistency signals are used to filter client updates, synthesize synchronization constraints, revise summaries, or report dependency violations (Lee et al., 2024, Nair et al., 2018, Liu et al., 2022, Greifenberg et al., 2015). This suggests a broader CFP pattern: a host system emits an output, an auxiliary component evaluates that output against a consistency criterion, and the resulting signal is routed back into optimization, aggregation, or developer workflow.

1. Scope, terminology, and acronym ambiguity

The acronym is overloaded across recent literature. In ReLoop, CFP means Consistency Feedback Plugin. In federated learning, the closest match is a virtual data-driven consistency scoring plugin that is explicitly described as a plugin but not abbreviated as CFP. In compiler optimization, CFP instead means Communication-Free Preserve and denotes an automatic intra-operator parallelization system rather than a plugin. In ophthalmology, CFP commonly means Color Fundus Photographs, and UWF-CFP means Ultra-WideField Color Fundus Photography (Yang et al., 7 Jul 2025, Lee et al., 2024, Hu et al., 1 Apr 2025, Wang et al., 2024, Daho et al., 2023).

Context	Meaning of CFP	Role
ReLoop	Consistency Feedback Plugin	Frozen reflective supervision for MLLMs
Federated learning	Consistency scoring plugin	Pre-aggregation Byzantine filter
Compiler systems	Communication-Free Preserve	Profiling-based auto-parallelization
Ophthalmology	Color Fundus Photographs	Retinal imaging modality
Ophthalmology	Ultra-WideField Color Fundus Photography	Panoramic fundus imaging modality

Because of that ambiguity, the phrase is best interpreted by context. In software and machine-learning settings, “plugin” usually denotes a modular component attached to a larger system; in medical-imaging papers, “CFP” usually denotes an imaging modality rather than a feedback module. The exact ReLoop usage is the clearest modern anchor for the term, while several other papers instantiate the same underlying idea of consistency-derived feedback without sharing the acronym.

2. Closed-loop consistency supervision in multimodal models

In ReLoop, CFP is a training-time mechanism for hallucination mitigation in multimodal LLMs used for open-ended visual question answering. The framework is described as “seeing twice and thinking backwards”: the backbone model $M$ first maps image $I$ and question $Q$ to answer $A$, and the answer is then pushed through reflective consistency pathways that attempt to reconstruct question semantics, recover visually compatible description, and align internal attention (Yang et al., 7 Jul 2025).

The plugin has two frozen modules. CFP-Lang is a MiniGPT-4-based reverse question reconstructor that maps $(A,I)$ to candidate proxy questions $\{\hat Q_1,\hat Q_2,\ldots,\hat Q_k\}$. A semantic aggregator $S$, implemented as a frozen BERT encoder plus a single-layer MLP scorer in the appendix description and treated as trainable in the framework description, ranks candidates using BERTScore and selects $\hat Q^*$. The language consistency loss is

$$L_{\text{align}} = 1 - \text{BERTScore}(Q,\hat Q^*).$$

CFP-Vis is a BLIP-2-based visual describer that maps $(A,I)$ to a generated description $I$0, which is compared to the real image with CLIP: $I$1

The third signal is attention supervision. Decoder cross-attention maps $I$2 are aligned to an entropy-based pseudo-ground-truth heatmap $I$3 through

$I$4

These terms are combined with supervised fine-tuning and $I$5 regularization: $I$6 with $I$7, $I$8, $I$9, and $Q$0 set by Adaptive Consistency Weighting. The weighting rule sets $Q$1 when $Q$2, $Q$3 when it lies in $Q$4, and $Q$5 below $Q$6. Only the main model $Q$7 and semantic aggregator $Q$8 are updated during training; CFP-Lang, CFP-Vis, attention supervision, and CLIP remain frozen, and standard inference uses only the backbone.

Empirically, the closed loop improves hallucination-oriented metrics across several backbones. For MiniGPT-4, ReLoop changes POPE from $Q$9 to $A$0, CHAIR$A$1 from $A$2 to $A$3, F1 from $A$4 to $A$5, Faith from $A$6 to $A$7, and FaithS from $A$8 to $A$9. Internal analyses report that hallucinated outputs correlate with lower CLIP similarity, lower BERTScore, and higher attention entropy. The ablation table further shows that removing consistency supervision gives the worst hallucination and faithfulness performance, which makes CFP the central control signal in the ReLoop design.

3. Counterexample- and language-based feedback

A second CFP lineage emphasizes human- or developer-readable feedback rather than only differentiable losses. In the improved Correct Eventual Consistency tool, the target problem is invariant preservation under weak or causal consistency. The tool checks the three CISE-style obligations of sequential correctness, stability of preconditions under concurrency, and commutativity of concurrent operations. The added feedback mechanisms are counterexample generation and concurrency-control suggestions. When verification fails, the tool reports the failed statement, the values of the parameters of the operation, and the values of all variables in the failed expression. It then uses the counterexample to infer candidate parameter restrictions and corresponding tokens for synchronization. In the bank example, concurrent withdraw operations fail stability when the accountId values coincide, and the tool concludes that withdraw must acquire a token per accountId (Nair et al., 2018).

Natural-language summarization work pushes the same idea into textual generation. The DeFacto dataset contains human demonstrations and informational natural language feedback for factual consistency in summarization. Its annotation protocol asks annotators to detect errors, categorize them as intrinsic or extrinsic, provide explanations, select evidence sentences, write corrective instructions using six templates—Remove, Add, Replace, Modify, Rewrite, Others—and produce minimally edited factually consistent summaries. The dataset reports that $(A,I)$0 of annotated summaries contain at least one factual error, with $(A,I)$1 containing extrinsic errors, $(A,I)$2 intrinsic errors, and $(A,I)$3 both. Fine-tuned editing models can exploit this feedback directly: for T0pp, conditioning on document, candidate summary, instructions, and explanation yields DAE $(A,I)$4 and QAFactEval $(A,I)$5, and human evaluation reports that $(A,I)$6 of model-edited summaries are more factually consistent than the original outputs while $(A,I)$7 follow the provided instructions (Liu et al., 2022).

A more loss-centric variant appears in customer-feedback summarization, where the system generates factually corrupted summaries that mimic two dominant error classes: Wrong Entity Detection and Incorrect Product-Defect Description. Each training instance becomes $(A,I)$8, and the best-performing objective is a margin-style constrained contrast loss,

$(A,I)$9

Using this mechanism reduces the total amount of inconsistent summaries by $\{\hat Q_1,\hat Q_2,\ldots,\hat Q_k\}$0 for BART and $\{\hat Q_1,\hat Q_2,\ldots,\hat Q_k\}$1 for T5, while harmful regressions remain relatively rare at $\{\hat Q_1,\hat Q_2,\ldots,\hat Q_k\}$2 for BART and $\{\hat Q_1,\hat Q_2,\ldots,\hat Q_k\}$3 for T5 (Liu et al., 2021). Across these systems, the common structure is the same: expose the inconsistency in a form the host model can consume, then use that signal to revise behavior.

4. Consistency scoring as a pre-aggregation plugin in federated learning

In federated learning, the closest explicit CFP analogue is the virtual data-driven consistency scoring plugin for Byzantine resilience. The plugin is inserted on the server side before aggregation and can be attached to existing FL methods such as FedAvg, FedProx, FedDyn, FedRS, FedSAM, and FedSpeed. Its input is the set of local client models together with the current global model, and its output is a trusted subset of clients for aggregation (Lee et al., 2024).

The mechanism operates on synthetic probe data. The server generates virtual samples

$\{\hat Q_1,\hat Q_2,\ldots,\hat Q_k\}$4

computes each client’s deviation from the current global model,

$\{\hat Q_1,\hat Q_2,\ldots,\hat Q_k\}$5

and extracts features $\{\hat Q_1,\hat Q_2,\ldots,\hat Q_k\}$6. Pairwise client consistency is defined by average cosine similarity,

$\{\hat Q_1,\hat Q_2,\ldots,\hat Q_k\}$7

and each client receives an average consistency score

$\{\hat Q_1,\hat Q_2,\ldots,\hat Q_k\}$8

The server sorts the scores, rejects the lowest $\{\hat Q_1,\hat Q_2,\ldots,\hat Q_k\}$9 clients, defines the surviving set $S$0, and aggregates only that set.

This is hard feedback rather than soft regularization. A client is either retained or excluded in a given round, and the paper does not describe long-term reputation accumulation. Empirically, the plugin is strong under targeted poisoning. Vanilla FedAvg drops from $S$1 to $S$2 as the compromise ratio $S$3 increases to $S$4, whereas FedAvg plus the plugin achieves above $S$5 even at $S$6. Under untargeted poisoning, FedAvg, FedProx, FedDyn, and FedRS with the plugin maintain roughly $S$7 even at $S$8, although the gains are weaker than under targeted attacks. The method assumes the number $S$9 of malicious clients is known and works best when benign clients form the majority consistency cluster, so its robustness is substantial but conditional.

5. Architectural consistency checking in plugin-based software systems

In software architecture, CFP is realized literally as an IDE plugin that checks whether implementation-level plugin dependencies conform to an architectural specification. The central artifact is DepCoL, the Dependency Constraint Language, which defines constraints over plugins, features, plugin groups, and feature groups in Eclipse-based systems. Dependencies are extracted from manifest files: plugin $\hat Q^*$0 depends on plugin $\hat Q^*$1 if $\hat Q^*$2 is listed as a required bundle in the manifest of $\hat Q^*$3. This makes the checker architecturally significant even when dependencies are declared but not directly visible in source-level references (Greifenberg et al., 2015).

DepCoL supports a feature base, a plugin base, logical groups, and three dependency statuses: allow, forbid, and tolerate. Forbidden dependencies may be marked with severities critical, error, or warning; tolerated dependencies are also reported as warnings but remain semantically distinct. The language also supports refinement by order. A broad rule can be declared first and later overridden by a more specific rule. The checker formalizes this by mapping every high-level constraint to a set of ordered plugin pairs and processing the dependency model from end to beginning, so later constraints refine earlier ones on overlapping pairs.

The Eclipse implementation maintains four disjoint relations, Rallowed, Rcritical, Rerror, and Rwarning, and records which concrete DepCoL rule classified each pair. It reports violations through an Eclipse view grouped by severity and through error markers on violating manifest files. This produces immediate development-time feedback rather than post hoc audit. The checker is specialized to direct manifest dependencies, is Eclipse-centric, and does not yet consider transitive dependencies, but it establishes a clear software-engineering CFP pattern: encode intended consistency declaratively, monitor actual dependency edges incrementally, and return actionable diagnostics as soon as a violation is introduced.

6. Recurrent design patterns, evaluation issues, and limits

Across these literatures, several recurrent design patterns emerge. One is the use of a stable anchor: ReLoop freezes CFP-Lang and CFP-Vis during backbone training, the federated plugin scores client updates relative to the current global model, CEC checks executions against fixed invariants and preconditions, and DepCoL checks manifests against an explicit architectural rule base (Yang et al., 7 Jul 2025, Lee et al., 2024, Nair et al., 2018, Greifenberg et al., 2015). Another is the separation between diagnosis and action. ReLoop turns answer inconsistency into losses, the FL plugin turns inconsistency into client rejection, CEC turns failed proofs into counterexamples and tokens, and DeFacto-style summarization turns factual inconsistency into explanations, instructions, evidence, and edited summaries (Liu et al., 2022).

The limits are equally recurrent. ReLoop depends on pretrained reflective modules and is weaker on relation and event hallucinations; DeFacto is built from XSum and PEGASUS outputs and therefore reflects a specific domain and base-generator distribution; CEC currently infers synchronization suggestions only from inequality restrictions on parameters; the FL plugin assumes the number $\hat Q^*$4 of malicious clients is known; and the Eclipse checker is restricted to direct Require-Bundle dependencies rather than transitive reachability (Yang et al., 7 Jul 2025, Liu et al., 2022, Nair et al., 2018, Lee et al., 2024, Greifenberg et al., 2015). These are not marginal details: they determine whether a CFP is best understood as a training-time supervisor, a runtime filter, an interactive debugger, or a design-time conformance checker.

Evaluation of CFPs is also nontrivial. A plausible implication is that raw consistency should not always be read in isolation. The contrast-set study on relative consistency shows that raw consistency can be misleading unless it is contextualized by the accuracy-constrained set of achievable consistency values, and it defines

$\hat Q^*$5

with $\hat Q^*$6 derived combinatorially from bundle structure (Johnson et al., 2023). That observation does not itself define a plugin, but it provides a useful warning for CFP benchmarking: a single consistency score may confound actual robustness with accuracy, task structure, or bundle geometry.

A further domain-specific lesson comes from multimodal diabetic-retinopathy assessment. A CFP-oriented design discussion built around fundus-photo-based grading proposes cross-checking fundus predictions against OCTA and notes that OCTA is stronger at the $\hat Q^*$7 mild NPDR cutoff ($\hat Q^*$8 vs $\hat Q^*$9) while fundus photography is much stronger at $$L_{\text{align}} = 1 - \text{BERTScore}(Q,\hat Q^*).$$0 PDR ($$L_{\text{align}} = 1 - \text{BERTScore}(Q,\hat Q^*).$$1 vs $$L_{\text{align}} = 1 - \text{BERTScore}(Q,\hat Q^*).$$2). This suggests modality-aware consistency policies rather than symmetric ones: a consistency module may need branch-specific trust rules instead of treating all disagreement as equally informative (Daho et al., 2023).

Taken together, the literature does not define one canonical CFP architecture. It instead defines a research pattern: a consistency signal is extracted from semantics, vision, attention, counterexamples, virtual probes, dependency rules, or human language; that signal is converted into losses, thresholds, warnings, or edits; and the host system uses it to reduce hallucination, reject adversarial updates, preserve invariants, or counteract architecture erosion.