Skip to main content

​
Get up and running

This guide will walk you through creating an account, analyzing your first argument, and understanding the results. You’ll be visualizing complex arguments in under 5 minutes.
1

Create an account

Visit the application and click “Sign up” to create your account. See Authentication for details.
// The signup process uses Firebase authentication
await createUserWithEmailAndPassword(auth, email, password);
You’ll need a valid email address and a secure password to create your account.
2

Choose your input method

Once logged in, you’ll see three input options:
Enter a topic or question for AI to research and analyze.Example topics:
  • “The pros and cons of universal basic income”
  • “Should social media be regulated?”
  • “Electric vehicles vs gasoline cars”
3

Submit for analysis

Click the “Analyze Arguments” button to start the AI analysis.
// The form submits with input type and authentication token
<form action={formAction}>
  <input type="hidden" name="inputType" value={inputType} />
  <input type="hidden" name="authToken" value={authToken} />
  <Textarea name="input" placeholder={placeholder} required />
</form>
Analysis typically takes 30-60 seconds. Don’t close the browser tab during this process.
4

Explore your results

Once complete, you’ll see your interactive argument map with multiple visualization options.

​
Input formats

The tool accepts three types of input, each optimized for different use cases.

​
Topic analysis

When you select the Topic input:
  • Enter a subject, question, or debate topic
  • The AI researches and constructs arguments from multiple perspectives
  • Best for: Exploring new subjects, educational purposes, debate preparation
Example: 
Input: "The impact of artificial intelligence on employment"

Result: AI-generated analysis of arguments for and against AI's 
impact on jobs, with evidence from multiple perspectives

​
URL analysis

When you provide a URL:
  • The tool fetches and analyzes the content from the web page
  • Extracts the main argument structure from the article
  • Best for: Analyzing specific articles, fact-checking claims, understanding author’s position
Example: 
Input: https://www.example.com/climate-change-article

Result: Structured breakdown of claims, evidence, and 
counterclaims from the article

​
Document analysis

When you upload or paste a document:
  • PDF files are automatically parsed to extract text
  • Text and Markdown files are processed directly
  • Best for: Research papers, internal documents, long-form content
Example workflow: 
// PDF parsing is handled automatically
const pdf = await pdfjsLib.getDocument(typedArray).promise;
let text = '';
for (let i = 1; i <= pdf.numPages; i++) {
  const page = await pdf.getPage(i);
  const content = await page.getTextContent();
  text += content.items.map(item => item.str).join(' ');
}
Image-based PDFs (scanned documents) may not work correctly as the tool requires text content to analyze.

​
Understanding your results

After analysis completes, you’ll see a comprehensive breakdown of the argument structure.

​
Argument blueprint

The core of your results is the argument blueprint—a structured representation of all arguments: 
type ArgumentNode = {
  id: string;
  parentId: string | null;
  type: 'thesis' | 'claim' | 'counterclaim' | 'evidence';
  side: 'for' | 'against';
  content: string;
  sourceText: string;
  source: string;
  fallacies: string[];
  logicalRole: string;
};
Each node represents:
  • Thesis: The main argument or position
  • Claim: Supporting argument for the thesis
  • Counterclaim: Opposing argument against the thesis
  • Evidence: Facts, data, or examples supporting claims

​
Analysis components

Your results include:
  1. Summary: High-level overview of the main argument
  2. Analysis: Detailed breakdown of argument structure and quality
  3. Social Pulse: Public sentiment and social media discussion
  4. Visual Maps: Interactive visualizations (see below)

​
Visualization modes

Explore your argument map using five different visualization modes. Each offers unique insights into the argument structure.

Balanced view

Side-by-side comparison of arguments for and against the thesis

Tree view

Hierarchical tree showing parent-child relationships between claims

Pillar view

Column-based organization grouping related argument chains

Circular view

Radial layout emphasizing connections and relationships

Flowchart view

Process-oriented flow showing logical progression

​
Switching between views

Use the toolbar at the top of your analysis to switch between visualization modes: 
type VisualizationMode = 'balanced' | 'tree' | 'pillar' | 'circular' | 'flowchart';

// Switch views using the toolbar
const [viewMode, setViewMode] = useState<VisualizationMode>('balanced');
Each view uses the same underlying argument blueprint but presents it differently to highlight various aspects of the argument structure.

​
Social pulse

Every analysis includes a social pulse sidebar showing:

​
Sentiment summary

AI-generated summary of public sentiment on your topic, including:
  • Overall tone (positive, negative, neutral)
  • Key themes in public discussion
  • Notable perspectives

​
Real tweets

Curated tweets discussing your topic with:
  • Author information and profile
  • Engagement metrics (likes, retweets, replies)
  • Timestamp of posting
type Tweet = {
  id: string;
  text: string;
  author: {
    name: string;
    username: string;
    profile_image_url: string;
  };
  public_metrics: {
    retweet_count: number;
    reply_count: number;
    like_count: number;
    impression_count: number;
  };
  created_at: string;
}
The social pulse can be toggled on/off using the sidebar toggle button in the toolbar.

​
Export options

Save and share your analysis using the export features in the toolbar.

​
Export as image

Download your current visualization as a PNG file:
  • Captures the exact view you’re seeing
  • Useful for presentations and reports
  • Includes all visible nodes and connections

​
Export as JSON

Download the raw argument data:
  • Complete argument blueprint structure
  • All metadata and relationships
  • Can be re-imported or processed programmatically
{
  "blueprint": [
    {
      "id": "node-1",
      "type": "thesis",
      "side": "for",
      "content": "Main argument statement",
      "fallacies": [],
      "logicalRole": "Central claim"
    }
  ],
  "summary": "Analysis summary...",
  "analysis": "Detailed analysis..."
}

​
Next steps

Learn about authentication

Understand how user accounts and Firebase auth work

Back to introduction

Return to the main documentation page

Build docs developers (and LLMs) love

Get started for freeTalk to us