The article “Trust in the Age of Mediated Reality” raises an important point: it is not enough to confirm that we are seeing the original source. We also need to understand why we should consider its claims well supported. That calls for tools that make reasoning visible and open to inspection, rather than asking us simply to trust the author.
But what does it mean to “see an argument”? It means breaking a text into claims and showing how they connect: what serves as evidence, what conclusion is drawn, what objections exist, and which part of the reasoning they address. A map like this can reveal not only gaps in logic, but also rhetorical moves that substitute emotional pressure, false dilemmas, or appeals to authority for evidence.
Imagine a browser extension that builds such a map directly from an article, post, or other text on a webpage. It would not issue a verdict of “true” or “false”. Instead, it would display the structure of the reasoning and help readers examine it for themselves.
A possible pipeline
1 Webpage text → Argdown. The extension extracts the text and sends it to Argunaut, a model designed by DebateLab to generate and analyze argument maps in Argdown syntax. The result is a structured representation of claims, arguments, premises, and relations of support or opposition.
One caveat matters: the model does not recover the one definitive structure of an argument from the text. Mapping an argument is an act of interpretation. Which claims the model selects, how it paraphrases them, and which relationships it infers all matter. Readers should be able to trace map elements back to the original passages and correct the reconstruction.
2 Argdown → AIF. The next step is to convert the map into the Argument Interchange Format (AIF), a graph-based format for representing arguments. AIF makes it possible to exchange argument data between tools and analyze it further.
I have not found a ready-made tool for this conversion specifically in browser-based JavaScript. Node.js implementations and projects do exist, though. So the task may not require building the conversion from scratch; it may be a matter of investigating existing implementations and figuring out how to bundle or adapt them for the browser.
3 AIF → visualization. The resulting graph could be displayed with Online Visualisation of Argument (OVA3), a visual argument-analysis tool from ARG Tech. OVA3 works with AIF and is designed to support the analysis of both simple and more complex argument structures.
Visualization is not decoration, nor is it a final “trust score”. Its purpose is to help readers see, for example, that a central conclusion depends on a single unsupported premise, that several reasons are really repetitions of the same point, or that an objection targets a premise rather than the conclusion itself.
The next layer: checking and highlighting problems
A further layer could run automated checks over the map. It might flag possible contradictions, unsupported leaps from premises to conclusions, false dilemmas, circular reasoning, or shifts in the meaning of a claim. Some checks would rely on rules and argumentation schemes; others would require probabilistic analysis and human review.
Results could appear as statistics and highlights on the map: which kinds of issues were detected, which nodes they relate to, and why the system flagged them. The word “possible” is important here. Detecting a pattern does not prove that an author intended to manipulate the reader, and a lack of flags does not guarantee sound reasoning.
I have not come across separate implementations of these checks specifically as browser-based JavaScript code. But once an argument has been represented structurally, and the rules for detecting certain fallacies are known, the task does not seem out of reach. It could combine formal checks, heuristics, and explainable suggestions - with a way for users to challenge each flag.
Not a judge, but a magnifying glass
The value of such an extension would not be to replace human judgment with a machine verdict. On the contrary, it would make the material for judgment easier to inspect: what exactly is being claimed, what supports the conclusion, where fact ends and assumption begins, and which parts of the reasoning deserve closer attention.
A tool like this would not eliminate the need for trust. But it could make trust more concrete. Instead of “I believe this author,” a reader could say: “I can see the line of reasoning, and I can examine its individual steps”. That is a practical move from trust toward verifiability.
The creators of Argunaut and OVA3 are building important parts of this infrastructure. The significance of their work may become clear only when these and other open tools come together in an argument- and claim-verification tool accessible to everyone. If you think this work matters, support the projects by starring or following them: OVA3 on GitHub and DebateLab on Hugging Face.
