ArgLLM-App: An Interactive System for Argumentative Reasoning with Large Language Models
| Authors | Adam Dejl et al. |
| Year | 2026 |
| Field | NLP |
| arXiv | 2602.24172 |
| Download | |
| Categories | cs.CL, cs.AI |
Abstract
Argumentative LLMs (ArgLLMs) are an existing approach leveraging Large Language Models (LLMs) and computational argumentation for decision-making, with the aim of making the resulting decisions faithfully explainable to and contestable by humans. Here we propose a web-based system implementing ArgLLM-empowered agents for binary tasks. ArgLLM-App supports visualisation of the produced explanations and interaction with human users, allowing them to identify and contest any mistakes in the system's reasoning. It is highly modular and enables drawing information from trusted external sources. ArgLLM-App is publicly available at https://argllm.app, with a video demonstration at https://youtu.be/vzwlGOr0sPM.
Engineering Breakdown
Plain English
undefined
Core Technical Contribution
The core contribution is implementing an end-to-end interactive system that operationalizes ArgumentLLMs (a prior conceptual approach) into a production-ready web application. Rather than just proposing the ArgumentLLM concept theoretically, this work engineers a modular architecture that bridges LLMs with computational argumentation frameworks, enabling real-time visualization of argument structures and human-in-the-loop contestation. The system's modularity allows it to draw from external trusted data sources, moving beyond purely language model outputs to ground reasoning in verifiable information. This represents a shift from explainability as a post-hoc property to explainability as a core design principle embedded into the decision-making pipeline itself.
How It Works
The system takes a binary decision task as input and feeds it to an ArgumentLLM agent that generates structured arguments rather than just a binary output. The LLM produces a set of premises (facts or claims) and a logical structure connecting those premises to a conclusion, effectively building an argumentation graph. This argumentation structure is then visualized in the web interface, allowing human users to inspect each premise, the logical connections, and the final claim. Users can interact by identifying problematic premises or logical steps and contesting them—this feedback loop enables the system to refine its reasoning or acknowledge human corrections. The modular architecture allows external information sources to be queried to validate premises, grounding the argumentation in trusted data rather than relying solely on LLM-generated claims. The output is both a decision and a human-readable, contestable justification.
Production Impact
For engineers building AI systems in high-stakes domains (legal, medical, financial, policy), ArgLLM-App addresses a critical pain point: regulators and users increasingly demand not just predictions but auditable, contestable reasoning. Adopting this approach means shifting your pipeline from end-to-end neural networks toward hybrid systems that interleave LLM reasoning with structured argumentation and external data validation, which increases interpretability at the cost of additional orchestration complexity. Integration cost is moderate—you need to wrap your LLM calls to extract structured arguments, build or integrate a visualization layer, and set up a feedback mechanism, but the modular design means you can plug in different LLMs or data sources without rewriting the core logic. The latency impact depends on whether you cache argument structures and how many external sources you query for validation; most binary tasks should complete in 1-5 seconds. The real win is defensibility: in regulatory environments or when errors carry high costs, the ability to show your reasoning and let humans contest it often matters more than raw accuracy.
Limitations and When Not to Use This
The system assumes that binary decision tasks are the primary use case; multi-class or regression problems would require architectural extensions not discussed in the abstract. The approach depends on the LLM's ability to generate coherent, logical argument structures—if the model tends to hallucinate premises or produce invalid logical chains, the visualization becomes misleading even if transparent. There is limited discussion of what happens when human contestation reveals errors: does the system have a mechanism to learn from corrections, or does it simply log them? The quality of the system is heavily dependent on the reliability of external data sources used for validation; if those sources are biased or incomplete, the argumentation is only as sound as its inputs. Finally, the paper doesn't address computational cost of generating full argument structures for every decision, which could be expensive at scale compared to simpler LLM-based classifiers.
Research Context
This work builds on the emerging field of computational argumentation applied to LLMs, which seeks to make neural models' outputs more transparent and defensible. It extends prior theoretical work on ArgumentLLMs by moving from concept to implementation, similar to how systems papers operationalize research ideas. The broader context is the growing emphasis on explainable AI and human-in-the-loop systems, responding to regulatory pressure (GDPR, AI Act) and user demand for contestable decisions. This opens research directions in how to efficiently structure LLM outputs for argumentation, how to learn from human contestation feedback, and how to scale argumentation visualization to complex, multi-step decision processes.
:::tip Subscribe Get weekly breakdowns of papers like this in AI Letters - the newsletter for engineers building production AI systems. :::