LLM-Assisted Data Cleansing

• LLM-assisted data cleansing is a process where advanced language models automate and enhance data quality operations such as standardization, anomaly detection, and imputation.
• It leverages methodologies like prompt-based end-to-end pipelines, automatic code synthesis, and agentic workflow orchestration to tackle diverse data challenges.
• This approach shows improved precision, recall, and cost efficiency, outperforming traditional rule-based methods in handling complex data quality issues.

LLM-assisted data cleansing denotes the application of advanced transformer-based LLMs to automate, enhance, or orchestrate the identification and remediation of errors, inconsistencies, or quality issues in datasets. LLMs are utilized across diverse modalities—including tabular, textual, code, and even multimodal (e.g., image-derived tables)—to standardize formats, detect anomalies, impute missing values, and enable higher-order cleaning operations. Their application represents a paradigm shift from rigid, rule-based systems toward prompt-driven, context-aware, and agentic approaches capable of leveraging emergent semantic understanding, generalization, and code-synthesis capabilities (Zhou et al., 22 Jan 2026).

1. LLM-Assisted Data Cleansing: Definitions and Taxonomy

LLM-assisted data cleansing comprises three canonical sub-tasks (Zhou et al., 22 Jan 2026):

• Data Standardization: Apply or learn a function $$f_\mathrm{std} : (\mathcal{D}, \mathcal{C}) \rightarrow \mathcal{D}_\mathrm{std}$$ such that a dataset $\mathcal{D}_\mathrm{std}$ satisfies all consistency constraints $\mathcal{C}$ (e.g., date formats, casing, value representation).
• Data Error Processing: Given error types $\mathcal{K}$, a detector $f_\mathrm{id}$ isolates erroneous entries $\mathcal{D}_\mathrm{err}$ in $\mathcal{D}$; a repair function $f_\mathrm{fix}$ then produces a cleaned dataset $\mathcal{D}_\mathrm{fix}$, satisfying $$f_\mathrm{id}(\mathcal{D}_\mathrm{fix}) = \varnothing$$.
• Data Imputation: Missing values in $\mathcal{D}_\mathrm{std}$0 are filled via $\mathcal{D}_\mathrm{std}$1, often by minimizing an imputation loss (e.g., RMSE or token likelihood).

The LLM can serve as the standardization, error detection, repair, or imputation operator via zero/few-shot prompting, code synthesis, or as a reasoning agent in hybrid pipelines.

A high-level taxonomy of LLM-mediated cleansing approaches encompasses:

• Prompt-based end-to-end: Structured prompts with in-context examples, chain-of-thought (CoT), and self-consistency voting (Ma et al., 2023, Choi et al., 2024).
• Automatic Code Synthesis: LLM generates executable code (e.g., Python/UDF) for format parsing, extraction, or repair rules (Zhou et al., 22 Jan 2026).
• Agentic / Workflow-Orchestrated: LLM acts as a reasoning agent, plans and invokes API/tool calls, and refines multi-step workflows with external tools such as OpenRefine (Li et al., 2024, Santos et al., 10 Feb 2025).
• Rule/Constraint Synthesis: LLMs extract or synthesize data quality rules, e.g., ontological or functional dependencies (OFDs) or matching/denial constraints (Biester et al., 2024, Akella et al., 11 Sep 2025).
• Hybrid and ML-augmented: LLM labels candidate anomalies, then lightweight models scale detection/repair to full data (Zhou et al., 22 Jan 2026).

2. Architectural Patterns and Workflow Decompositions

LLM-assisted cleansing pipelines universally integrate task decomposition, prompt engineering, and tool interoperation. Three dominant architectural patterns are evident:

• LLM-GDO: LLM as Generic Data Operator In this pattern, user-defined prompts (UDPs) encapsulate cleansing logic in natural language, replacing conventional UDFs. Each record (or batch) is routed through a centrally maintained LLM inference engine; outputs are parsed, validated, and written back. Prompt repositories and version control are crucial for maintainability (Ma et al., 2023).
• Agentic Workflow Synthesis LLM agents (e.g., Harmonia or AutoDCWorkflow) interactively synthesize stepwise data cleaning or harmonization pipelines. The agent operates in a loop—assessing column quality, mapping schemas, generating operation and argument choices, and invoking deterministic tool primitives (API, transformation libraries) (Li et al., 2024, Santos et al., 10 Feb 2025). User-in-the-loop adjustments are integrated into prompt history, inducing immediate behavior corrections.
• Pipeline and Guardrail Enrichment Frameworks like Cocoon and the three-stage system of (Akella et al., 11 Sep 2025) combine statistical profiling (e.g., outlier detection, distribution analysis) with LLM-based semantic rule synthesis and code generation. Generated rules are guarded by dedicated conflict-resolution filters, rubric-based value checkers, explicit semantic/type guards, and automated unit testing.

Pattern	Description	Key References
LLM-GDO	Prompts replace code in row-wise transformations	(Ma et al., 2023)
Agentic Workflow	LLM plans, calls primitives, and incorporates feedback	(Li et al., 2024)
Guardrail-Enriched	Statistical + LLM-driven, multilayer validation	(Zhang et al., 2024, Akella et al., 11 Sep 2025)

3. Core Methodologies: Prompt Engineering, Rule Extraction, and Self-Consistency

LLM-mediated pipelines critically rely on prompt design, with best practices including:

• Prompt Structure and Few-shot Examples: Prompt templates present the task and schema, enumerate supported operations, and provide 3–5 diverse edge-case examples. Explicit output formatting requirements (TSV/JSON) and step-by-step CoT are enforced to reduce hallucination and promote semantic validity (Ma et al., 2023, Li et al., 2024, Choi et al., 2024).
• Chain-of-Thought and Self-Consistency: For tasks such as classification of noisy records, CoT prompts are composed to elicit reasoning, followed by multiple LLM calls with majority voting for each example ("self-consistency"), reducing individual run variance and mimicking ensemble annotation (Choi et al., 2024).
• Rule and Constraint Induction: LLMs are prompted to produce human-readable rule cards (JSON objects), which are then parsed, curated, and synthesized into executable validators. Retrieval-augmented generation (RAG) incorporates external domain knowledge and few-shot rule exemplars, further grounding outputs (Akella et al., 11 Sep 2025).
• OFD Synthesis: In context-aware cleaning (LLMClean), LLMs induce ontological FDs (matching, denial, temporal, capability, etc.) through column mapping to domain ontologies, semantic clustering, and prompt ensembling for stable rule extraction (Biester et al., 2024).

4. Evaluation Benchmarks, Baselines, and Empirical Results

Robust evaluation leverages domain-standard datasets (e.g., UCI, Kaggle, NYPL Menus, hospital, code-generation datasets), with noise/model error injection for rigorous assessment.

Common Metrics

• Tabular/Cleaning: Precision, recall, F1-score at the cell/row-level, error-detection coverage, workflow operation F1, RMSE for imputation (Li et al., 2024, Zhang et al., 2024, Biester et al., 2024).
• Code-Generation/Plan-based: Pass@K for function correctness, helper function statistics, code readability measures (informal), data efficiency (performance vs. volume) (Jain et al., 2023).
• Annotation/Summarization: Downstream task accuracy (e.g., ROUGE, BERTScore), cost savings, and human validation accuracy (Choi et al., 2024).
• Panel Creation (Historical Data): Missing/incorrect output rate, $\mathcal{D}_\mathrm{std}$2, error-only metrics, regression diagnostics (Bäcker-Peral et al., 16 May 2025).

Key results consistently demonstrate:

• LLM-based workflows outperform classical or monolithic statistical approaches on F1/precision/recall by 10–30 points across multiple domains (Zhang et al., 2024, Akella et al., 11 Sep 2025, Biester et al., 2024).
• Plan-driven code cleaning improves Pass@1 by 23% and Pass@25 by 30%, and increases data efficiency (6× less data needed for equal performance) in code generation (Jain et al., 2023).
• Annotation-based cleansing boosts summarization ROUGE and BERTScores while reducing annotation costs by an order of magnitude (Choi et al., 2024).
• Multimodal LLM-based digitization yields a 100× cost reduction compared to outsourcing while preserving statistical validity in panel analyses (Bäcker-Peral et al., 16 May 2025).

5. Strengths, Limitations, and Pitfalls

LLM-based cleansing offers key advantages:

• Semantic Flexibility: Infer context-sensitive mappings, handle rare/edge-case formats, and adapt to evolving data domains (Ma et al., 2023, Biester et al., 2024).
• Low/No-Code: Drastically lowers barrier to workflow modification, supporting rapid data pipeline iteration via prompt tuning (Ma et al., 2023, Li et al., 2024).
• Explainability and Auditability: CoT and rule-card outputs permit more interpretable cleaning and debugging (Choi et al., 2024, Akella et al., 11 Sep 2025).
• Agentic Autonomy: Orchestrating API/tool flows and responding to interactive correction enhances expert productivity (Santos et al., 10 Feb 2025).

Limitations remain:

• Inference Cost and Latency: Model invocation is 10–100× slower than native UDFs; token and memory limits constrain context (Ma et al., 2023, Bendinelli et al., 9 Mar 2025).
• Scaling to Large Tables: Token budgets may force sampling in $\mathcal{D}_\mathrm{std}$3 regimes, risking missed rare errors (Bendinelli et al., 9 Mar 2025).
• LLM Hallucinations and Formatting Errors: Non-deterministic outputs or format deviations necessitate careful output parsing, unit testing, and self-consistency mechanisms (Ma et al., 2023, Akella et al., 11 Sep 2025).
• Complex Error Types: Distributional anomalies, covariate drift, or low-frequency misplacements are less amenable to row-/cell-wise text-only reasoning (Bendinelli et al., 9 Mar 2025).

Representative Limitation Table

Limitation	Consequence	Source
High token/compute cost	Slow or expensive cleansing	(Ma et al., 2023)
Context window limits	Ineffective large-table cleaning	(Bendinelli et al., 9 Mar 2025)
Incomplete error coverage	Missed distributional/multivariate errors	(Bendinelli et al., 9 Mar 2025)
LLM hallucination (invalid output)	Requires guardrails, explicit output checks	(Akella et al., 11 Sep 2025)

6. Best Practices and Prospective Research Directions

The following best practices and research priorities for LLM-assisted data cleansing have been synthesized:

• Hybrid Modularization: Employ local ML/statistical models for routine error detection, escalate semantically complex or rare cases to LLM (Zhou et al., 22 Jan 2026, Zhang et al., 2024).
• Retrieval Augmentation: Provide LLM with domain-specific few-shots, reference tables, or ontological schemas to mitigate hallucination and improve cross-domain generalization (Akella et al., 11 Sep 2025, Biester et al., 2024).
• Self-Verification and Guardrails: Implement prompt self-consistency, rubric-based rule evaluation, conflict-resolution filters, and automated unit testing for all rule/code synthesis outputs (Akella et al., 11 Sep 2025).
• Uncertainty Awareness: Estimate and threshold LLM confidence; defer low-certainty cases to human review or auxiliary models (Zhou et al., 22 Jan 2026).
• Workflow Versioning: Maintain versioned prompt and model libraries, track workflow changes, and enable rollbacks (Ma et al., 2023).
• Explainable Cleaning: Enforce explicit provenance, with rules mapping and rationales attached to each transformation (Zhou et al., 22 Jan 2026).

Prospective research targets include:

• Scalable Distributed Architectures: Hierarchical agentic orchestration and asynchronous LLM execution for large-scale deployment (Zhou et al., 22 Jan 2026).
• Global-Constraint Reasoning: Integrating LLM with external constraint solvers for dataset-level integrity checks (Zhou et al., 22 Jan 2026).
• Preference Learning in Interactive Agents: Learning user preferences from structured corrections to further minimize future interventions (Santos et al., 10 Feb 2025).
• Robust Evaluation Protocols and Benchmarks: Standardization of purpose-answer, value-level, and workflow-level metrics for cross-method comparison (Li et al., 2024, Zhou et al., 22 Jan 2026).
• Evidence-Grounded Generation: Mandating explicit citations or sample provenance for all LLM-generated annotation or enrichment (Zhou et al., 22 Jan 2026).

LLM-assisted data cleansing thus represents a maturing and increasingly application-ready paradigm, combining prompt-driven semantics, code generation, and agentic planning to approach or surpass human-level quality, albeit with important challenges and areas for methodological refinement.