ExpliCIT-QA: Transparent, Verifiable QA Systems

• ExpliCIT-QA is a family of transparent QA approaches that expose the complete reasoning, intermediate computations, and code execution for enhanced auditability.
• The methodology employs code-based pipelines and reversible multi-agent reasoning to provide explicit, step-by-step explanations and error recovery in high-stakes domains.
• Explicit diversity techniques, including spatial, question-type, and entity conditioning, improve training data variety and boost QA performance metrics.

ExpliCIT-QA denotes a family of approaches that operationalize explicitness, transparency, or controllability in Question Answering (QA) and related multimodal inference settings. Central to the ExpliCIT-QA paradigm is the requirement that QA systems not only produce answers but also expose, by design, the full trajectory, intermediate computation, and decision mechanism underlying each response. The explicitness property encompasses diverse techniques, including code-based pipelines for table question answering, explicit diversity prompting in question answer generation, and reversible agent-based multi-hop reasoning for robust knowledge-intensive QA. These systems are distinguished by their capacity to provide human-auditable reasoning chains and error inspection for both research and safety-critical deployment.

1. Formal Problem Statement and Systemic Requirements

In the context of code-based multimodal QA, ExpliCIT-QA treats Table Visual Question Answering (TableVQA) as a transformation pipeline. Given a raster table image $I$ and a natural language question $Q$, the objective is to compute a machine-readable answer $A$ and a human-readable explanation $E$, while yielding full inspectability over intermediate representations, including table parses, stepwise reasoning, generated program code, and execution traces. Let $T = \mathrm{ExtractTable}(I)$ denote a normalized 2D matrix extracted from $I$, and let $S = \mathrm{CoT}(T,Q)$ be a chain of thought describing the reasoning steps $s_1,\ldots,s_k$. This is programmatically mapped, $C = \mathrm{GenCode}(S)$, to an executable Python/Pandas script, whose deterministic output $A = \mathrm{Exec}(C,T)$ serves as the formal answer. Each of these stages, along with the explanation $Q$0, is exposed for auditability (Lagos et al., 15 Jul 2025).

Beyond input-output transparency, ExpliCIT-QA mandates that all computation steps be verifiable and interpretable, which is essential for high-stakes applications such as finance and healthcare. Architectures that meet these requirements, such as code-based and agent-based pipelines, tightly control the inference process and generate audit trails inaccessible to “black-box” end-to-end neural models.

2. Explicit Diversity in Question Answer Generation

ExpliCIT-QA further refers to explicit diversity-controlled generation procedures for producing QA training data (Yadav et al., 2024). Rather than relying on implicit sampling or heuristic decoding diversity, these techniques enforce structured coverage over key axes:

• Spatial Diversity (POS): By partitioning an input document $Q$1 into $Q$2 segments and compelling the generator to condition on split position pos $Q$3, answer locations are distributed across the document, leading to reduced token overlap among generated questions.
• Question-Type Diversity (WH): Conditioning on WH-word (who, what, when, where, which, why, how, other) enforces maximal coverage over question forms.
• Entity Diversity (ENT): Explicitly instructing the model to generate QA pairs centered on different named entities (as identified by NER tagging) mitigates redundancy in generated data.

These control signals are realized in the prompting of pretrained LLMs (e.g., LLaMa, BART), both as single combined prompts and as multi-phase two-step models (e.g., predicting likely WH-type given POS before generating the QA). The explicit conditioning yields substantial increases in question and answer variety, as measured by token overlap (down to 30–36%) and coverage metrics (up to 95% for WH, 78% for POS, 64% for ENT), and results in statistically significant downstream improvements in standard QA metrics—for instance, +4.1 EM and +4.5 F1 in SQuAD$Q$4, and up to 12 EM/+15 F1 in low-resource SubjQA settings (Yadav et al., 2024).

3. Code-Based Multimodal Table Question Answering

ExpliCIT-QA systems for TableVQA are organized as multilayer modular pipelines (Lagos et al., 15 Jul 2025). The core process is as follows:

1. Multimodal Table Understanding: An image $Q$5 is parsed via vision-LLMs (e.g., Qwen-2.5-VL) using chain-of-thought prompting to yield a structured table $Q$6 with explicit transformation logs (such as “split multirow header” or “duplicate merged cells”).
2. Language-Based Reasoning: Qwen-3 is prompted to produce a precise, stepwise natural language plan $Q$7 over $Q$8.
3. Automatic Code Generation: $Q$9 is translated into executable Python using grammar-guided prompting to ensure syntactic correctness and practical use of Pandas.
4. Code Execution and Error Recovery: The resulting code $A$0 is run in a sandbox with the parsed table as input; exceptions prompt up to three automatic regeneration attempts, each incorporating the raw Python error message as additional feedback.
5. Explanatory Trace: An LLM-based code-to-text module renders a natural language rationale $A$1, grounded in the exact code segment that produced $A$2.

Each intermediate result (parsed $A$3, CoT reasoning $A$4, code $A$5, execution trace, and $A$6) is made available for inspection, allowing complete error diagnosis and step-by-step verification of the answer pipeline.

Evaluations on TableVQA-Bench across multiple sub-datasets (VWTQ, VTabFact, FinTabNetQA) show that ExpliCIT-QA with Qwen-3-14B achieves average exact-match accuracy comparable to recent GPT-4V→GPT-4 baselines, trading slight raw accuracy for exhaustive transparency and interpretability (Lagos et al., 15 Jul 2025).

4. Reversible Multi-Agent Reasoning for Error-Tolerant QA

In multi-hop factoid QA, explicitness also encompasses reversible logics within agent-based systems, as exemplified by the ReAgent architecture (Zhao et al., 10 Mar 2025). ReAgent comprises:

• Execution Layer: Includes task-decomposing, retrieving, verifying, and assembling agents, each with well-scoped roles and individual knowledge bases.
• Supervisory Layer: Supervises escalated conflicts and triggers high-level interventions or rollbacks.
• Interaction Layer: Implements a formal message-passing protocol for assertions, challenges, and rejections, while maintaining a globally consistent assertion set $A$7.

ReAgent introduces explicit backtracking via checkpoint graphs (local and global), enabling agents to:

• Revert to the last consistent state when a contradiction is internally detected (local backtracking).
• Escalate multi-agent conflicts for cross-agent rollbacks (global backtracking), potentially followed by explicit challenge and revision of conflicting assertions.

Empirical benchmarks (HotpotQA, 2WikiMultiHopQA, Musique) demonstrate that reversible inference—via local/global backtracking—provides an absolute average gain of 6% EM/F1 versus forward-only baselines, and a 4–8 percentage point drop when backtracking is ablated (Zhao et al., 10 Mar 2025). Structured conflict resolution logs accompany all outputs, ensuring interpretability of each error correction and answer path.

5. Interpretability, Auditability, and Application Domains

The principal operational advantage of ExpliCIT-QA architectures is their comprehensive audit trail. Since every computation—parse structure, reasoning trace, code logic, and answer justification—is stored and accessible, domain experts and downstream validators can:

• Identify failure points by inspecting the reasoning or code.
• Debug mapping errors in the visual parsing or chain-of-thought segments.
• Re-run or modify code using the same data and prompts.
• Trace system behavior for compliance audits in sensitive fields and under regulatory requirements.

By delegating deterministic logic (e.g., Pandas-based computation) to standardized, widely validated libraries, ExpliCIT-QA reduces exposure to LLM arithmetic or logic hallucinations. The approach thereby closes the explainability gap present in traditional end-to-end neural QA models (Lagos et al., 15 Jul 2025).

6. Empirical Results, Trade-Offs, and Future Directions

Explicit prompting and code- or agent-driven explicitness provide empirically validated gains in diversity and downstream QA performance, particularly in low-resource settings. Explicit prompts yield higher coverage and lower redundancy compared to nucleus or diverse beam search sampling, and agent-based approaches with explicit backtracking mechanisms prevent error propagation intrinsic to monotonic Chain-of-Thought reasoning, yielding both higher accuracy and answer traceability (Yadav et al., 2024, Zhao et al., 10 Mar 2025).

However, these systems introduce engineering trade-offs: explicit diversity prompting requires nontrivial prompt engineering and possible fine-tuning of multiple models; the inspection pipeline (in code-based TableVQA) increases latency versus monolithic neural baselines; explicit agent architectures are more modular but require careful orchestration and escalation protocols. Despite these costs, the fine-grained control over inference and the assurance of each step’s correctness are essential in regulated or mission-critical environments.

Prospective extensions include expanding explicit conditioning to multi-hop QA, integrating richer symbolic intermediate representations, embedding-based diversity rather than purely lexical overlap, and learning to optimize prompt coverage schedules adaptively. In sum, ExpliCIT-QA methodologies define a foundational shift toward transparent, verifiable, and controllable QA systems across both text and multimodal domains.