ABDA-NL: A Natural-Language Scenario Explorer for Argument-Based Reasoning
Structured argumentation frameworks such as ASPIC- compute whether claims are accepted under grounded semantics by chaining strict rules ($p_1,\ldots,p_n \rightarrow c$) and defeasible rules ($p_1,\ldots,p_n \Rightarrow c$), but interacting with them has traditionally required writing symbolic literals and move primitives. ABDA-NL solves this usability barrier by wrapping the ABDA engine in a natural-language web interface that renders arguments, attacks, and discussion-game explanations in plain English, and by using a large language model strictly as a translator and research assistant rather than a reasoner. Because the deterministic engine alone constructs arguments and assigns acceptance labels, users can explore and extend formal scenarios without losing logical guarantees.
ABDA-NL is a carefully engineered system paper that extends the prior ABDA engine with a polished natural-language interface, an LLM-assisted authoring pipeline, and a hosted service. Its main conceptual contribution is the architectural boundary that reserves all logical reasoning for the deterministic ASPIC- engine and confines the LLM to language tasks—translation, question answering, and prose generation—under strict syntactic validation and mandatory user confirmation. However, this is an extended demonstration abstract: there is no user study, no quantitative evaluation of interface usability, and no empirical measurement of whether the natural-language layer actually helps non-experts construct or understand argumentation frameworks. The system architecture is sound, but its utility for the claimed audience is asserted rather than demonstrated.
The strongest aspect of the work is its principled separation of concerns. The rendering layer is purely template-driven over the glossary, so every rule, explanation trace, and argument graph is produced deterministically without LLM involvement: 'The rendering layer turns formal objects into natural language purely through templates over the glossary: rules become if/then sentences that read "necessarily" for strict and "normally" for defeasible rules, and the panels, the explanation trace, the conclusion graph, and the raw aspic- listing are all generated from the same computed framework' (Section 3). Equally important is the validation pipeline for model-authored content: malformed identifiers, unknown rule references, and structurally impossible combinations are deterministically rejected, and the user must confirm any surviving proposal before it is applied (Section 5.2).
The paper makes several unsupported leaps from system description to claimed benefit. It positions ABDA-NL as a tool for users to explore scenarios 'without needing to engage in aspic- notation' (Section 1), yet there is no evidence—no user study, no comprehension test, no baseline comparison—that these users actually succeed at this task, or that the natural-language glosses preserve the nuance of the formal semantics. The what-if exploration, while useful, is limited to toggling existing assumptions and binary preference reversals between known conflicts; creating genuinely novel arguments still requires the LLM translator, whose semantic reliability is uncertain despite syntactic checks. The evaluation suite that qualifies a model for the hosted service is mentioned but not reported: pass rates, failure modes, or inter-model disagreement are omitted, so readers cannot judge whether the admission bar is high or merely nominal.
A second worry concerns semantic consistency: 'The formalization of a free-text request is not unique, and two runs may propose different candidates, for instance one that reuses an existing proposition and one that introduces a new one' (Section 5.2). Although the paper notes that this is harmless because every applied rule is validated and deterministic, the burden of catching semantic drift falls entirely on the user, who is assumed to understand the displayed ASPIC- syntax well enough to spot an incorrect formalization.
The evidence inside the paper supports the technical claims about system architecture and deterministic correctness, but it does not substantiate the broader claim that ABDA-NL makes formal argumentation accessible to a wider audience. The built-in scenarios are drawn from prior literature—most notably Prakken's reconstruction of Popov v. Hayashi—and the paper does not compare its interface approach to related tools such as OVA, ArguMed, or other structured-argumentation front-ends. The only mechanism that is stress-tested is the model-qualification suite (Section 5.3), yet no data from that suite is presented. As a result, the paper reads as a capable extended abstract for a demonstration, not as an empirically validated human-computer interaction contribution.
Reproduction of the core argumentation behavior is straightforward: the ABDA engine is embedded as a deterministic in-process library, all scenarios ship with the source code, and the hosted service requires no installation. The authors provide GitHub repositories, YAML/JSON import-export formats, and the full ASPIC- text of every scenario. However, reproducibility of the LLM-assisted features is gated by proprietary APIs and undisclosed prompt templates; while the paper describes prompt instructions in broad terms, the exact prompts and the schema-constrained tool calls are not published, and model outputs are explicitly non-deterministic. Additionally, the hosted trial credits are limited, so independent auditors who lack their own API keys may be unable to exhaustively test the authoring and question-answering pipelines.
ABDA-NL adds a natural-language interface to ABDA, a system for argument-based discussion using ASPIC- knowledge bases under grounded semantics. Users see which conclusions are accepted, rejected, or undecided, open an interactive rendering of the grounded discussion game to learn why, explore what-if alternatives by suspending assumptions and rules or changing preferences, ask questions that are answered from a scenario's reference documents, and author new facts, assumptions, and rules in plain English. A large language model provides the bridge between language and formalism: it answers questions from the documents and the current state of the scenario, and it translates plain-English edits into candidate formal statements. The deterministic ABDA engine remains the sole source of arguments, attacks, and acceptance labels, and every proposal of the model is validated and confirmed by the user before it takes effect.
Pick a starting point or write your own. Challenges run in the background, so you can keep reading while the AI investigates.
No challenges yet. Disagree with the review? Ask the AI to revisit a specific claim.