Major refocus: System architecture over vote results

Complete redesign emphasizing the AI system framework:

App structure (no emojis):
1. System Architecture - multi-agent design, structured outputs, model config
2. System Prompt Design - shows generic templates, country explorer
3. Structured Output Schema - JSON constraints, validation rules, user prompt template
4. Task Execution - execution flow, CLI usage, output format
5. Case Study Gaza Ceasefire - consolidated all resolution content here

README updates:
- Focus on multi-agent simulation framework
- Emphasize structured outputs and JSON constraints
- Highlight task execution model
- Case study as example, not primary focus
- Technical implementation details front and center

Key improvements:
- All emojis removed from app
- Resolution content consolidated into single case study tab
- Primary focus on system design, not voting results
- Detailed execution flow and CLI documentation
- JSON schema and validation prominent
- Clear technical architecture exposition

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

README.md

@@ -1,8 +1,8 @@
 ---
-title: AI Agent UN - Gaza Ceasefire Resolution
-emoji: 🌍
+title: AI Agent UN - Multi-Agent Simulation Framework
+emoji: 🏛️
 colorFrom: blue
-colorTo: green
+colorTo: indigo
 sdk: gradio
 sdk_version: 4.44.0
 app_file: app.py
@@ -10,90 +10,108 @@ pinned: false
 license: mit
 ---
 
-# 🇺🇳 AI Agent UN: Gaza Ceasefire Resolution Simulation
+# AI Agent United Nations: Multi-Agent Simulation Framework
 
-An experimental Model United Nations simulation where AI agents representing all 195 UN member states vote on a ceasefire resolution for Gaza.
+A structured system for simulating international diplomatic decision-making using 195 AI agents with constrained JSON outputs.
 
-## 🎯 The Concept
+## System Overview
 
-This project explores how large language models can simulate international diplomatic interactions by creating AI agents that embody:
-- **Foreign policy positions** based on historical voting records
-- **Diplomatic style** reflecting each country's approach to multilateral diplomacy
-- **National interests** and regional alliances
-- **Cultural and ideological perspectives**
+This is an experimental framework demonstrating:
+- **Multi-agent coordination** across 195 independent AI agents
+- **Structured output constraints** with strict JSON schema validation
+- **Generic prompt templates** producing country-specific behaviors
+- **Task execution model** for running resolutions through all agents
 
-### How It Works
+## Architecture
 
-1. **Agent System Prompts**: Each of the 195 countries has a detailed system prompt that defines their:
-   - Historical positions on Middle East conflicts
-   - Key alliances and regional groupings
-   - Economic and security interests
-   - Past voting patterns on similar resolutions
+### Core Components
 
-2. **Structured Voting**: Each AI agent receives the ceasefire resolution text and responds with:
-   - A vote: YES, NO, or ABSTAIN
-   - A diplomatic statement explaining their position
+**Agent System Prompts**
+- 195 country-specific agents (one per UN member state)
+- Generic template structure (identical for all countries)
+- Only country name and P5 status differ between prompts
+- AI infers policy positions from training data
 
-3. **Analysis**: Votes are aggregated and analyzed by region, showing how different parts of the world approach the issue
+**Structured Output Schema**
+```json
+{
+  "vote": "yes" | "no" | "abstain",
+  "statement": "Brief explanation (2-4 sentences)"
+}
+```
 
-## 📊 The Resolution
+**Task Execution**
+- Python CLI for running simulations
+- Sequential processing of all 195 agents
+- JSON validation and error handling
+- Aggregated results with metadata
 
-**Motion**: Support for Ceasefire Agreement in Gaza and Commitment to Lasting Peace
+**Model Configuration**
+- Primary: Claude 3.5 Sonnet (claude-3-5-sonnet-20241022)
+- Temperature: 0.7
+- Max tokens: 800 per response
+- Provider: Anthropic API
 
-The resolution calls for:
-- Immediate and comprehensive ceasefire
-- Unhindered humanitarian access
-- Release of hostages and prisoners
-- Lifting of restrictions on Gaza
-- Two-state solution based on pre-1967 borders
-- International monitoring and accountability
+## What This Tests
 
-## 🤖 Technical Details
+- **LLM Geopolitical Knowledge**: How well models understand different countries' foreign policies
+- **Structured Outputs**: Consistency in producing valid JSON under constraints
+- **Multi-Agent Systems**: Coordinating hundreds of independent AI agents
+- **Prompt Engineering**: Generic templates yielding specific behaviors
+- **Error Handling**: Graceful degradation when agents produce invalid outputs
 
-- **Model**: Claude 3.5 Sonnet (claude-3-5-sonnet-20241022)
-- **Countries**: 195 UN member states
-- **Simulation Date**: October 9, 2025
-- **Vote Distribution**:
-  - ✅ YES: 190 countries (97.4%)
-  - ❌ NO: 3 countries (1.5%)
-  - ⚪ ABSTAIN: 2 countries (1.0%)
+## Technical Implementation
 
-## 🔍 Explore the Results
+**Execution Flow:**
+1. Load motion text from `tasks/motions/`
+2. Load 195 country agents
+3. For each agent: system prompt + user prompt → JSON response
+4. Validate and aggregate responses
+5. Save results with metadata
 
-Use the tabs above to:
-- **Vote Summary**: See the overall voting distribution
-- **Regional Analysis**: Compare how different regions voted
-- **Country Details**: Read individual countries' votes and diplomatic statements
-- **All Votes**: Browse the complete voting record
+**Command Line Interface:**
+```bash
+# Run simulation
+python scripts/run_motion.py 01_gaza_ceasefire_resolution
 
-## 🎓 Educational Value
+# With specific model
+python scripts/run_motion.py 01_gaza_ceasefire_resolution --model claude-3-5-sonnet-20241022
 
-This simulation demonstrates:
-- How AI can model complex geopolitical decision-making
-- The diversity of international perspectives on contentious issues
-- The role of historical context in diplomatic positions
-- Multi-agent AI systems in action
+# Test with sample
+python scripts/run_motion.py 01_gaza_ceasefire_resolution --sample 5
+```
 
-## ⚠️ Important Disclaimer
+## Case Study
 
-This is an AI simulation for research and educational purposes only. The positions expressed by the AI agents:
-- Do NOT represent actual government policies
-- Are NOT official diplomatic stances
-- Should NOT be considered authoritative or predictive
-- Are based on historical patterns, not current intentions
+The Space includes a case study demonstrating the system with a Gaza ceasefire resolution voted on by all 195 agents.
 
-The simulation is designed to explore how AI models understand and represent different national perspectives based on publicly available information about countries' historical positions.
+**Results:** 190 Yes, 3 No, 2 Abstain
 
-## 🔗 Links
+This serves as a concrete example of the framework in action, showing how generic prompts + model knowledge produce diverse, country-specific diplomatic responses.
 
-- [GitHub Repository](https://github.com/yourusername/AI-Agent-UN)
-- [Full Source Code](https://github.com/yourusername/AI-Agent-UN/blob/main/scripts/run_motion.py)
-- [Agent System Prompts](https://github.com/yourusername/AI-Agent-UN/tree/main/agents/representatives)
+## Research Applications
 
-## 🤝 Contributing
+- Testing LLM knowledge of international relations
+- Evaluating structured output consistency
+- Studying emergent behavior in multi-agent systems
+- Educational demonstrations of diplomatic complexity
 
-This is an experimental research project. Contributions, suggestions, and discussions are welcome!
+## Limitations
+
+This is a simulation for research and education:
+- AI positions based on training data, not actual policies
+- Does NOT predict real government decisions
+- Should NOT be considered authoritative
+- Real diplomacy involves classified information and human judgment
+
+## Open Source
+
+All code, prompts, and data available on GitHub:
+
+- Repository: https://github.com/danielrosehill/AI-Agent-UN
+- System Prompts: https://github.com/danielrosehill/AI-Agent-UN/tree/main/agents/representatives
+- Execution Script: https://github.com/danielrosehill/AI-Agent-UN/blob/main/scripts/run_motion.py
 
 ---
 
-Built with ❤️ using [Gradio](https://gradio.app) and [Claude](https://anthropic.com/claude)
+Built with Gradio | Powered by Anthropic Claude

app.py

@@ -27,7 +27,6 @@ def load_motion():
     except:
         return "Motion text not found."
 
-# Visualization functions
 def create_vote_summary_chart(data):
     vote_summary = data['vote_summary']
     fig = go.Figure(data=[go.Pie(
@@ -51,11 +50,11 @@ def get_country_response(country_name, data):
 
     for vote in data['votes']:
         if vote['country'].lower() == country_name.lower():
-            vote_emoji = "✅" if vote['vote'] == 'yes' else "❌" if vote['vote'] == 'no' else "⚪"
             response = f"""
-## {vote_emoji} Vote: {vote['vote'].upper()}
+**Vote:** {vote['vote'].upper()}
+
+**Diplomatic Statement:**
 
-### Diplomatic Statement:
 {vote['statement']}
             """
             return response, vote['country_slug']
@@ -66,80 +65,107 @@ data = load_data()
 country_names = sorted([v['country'] for v in data['votes']])
 motion_text = load_motion()
 
-# Create Gradio interface
-with gr.Blocks(title="AI Agent UN Experiment", theme=gr.themes.Soft()) as demo:
+# JSON schema for structured output
+json_schema = """{
+  "vote": "yes" | "no" | "abstain",
+  "statement": "Brief explanation (2-4 sentences)"
+}"""
 
-    gr.Markdown("""
-    # 🤖 AI Agent United Nations Experiment
+# User prompt template
+user_prompt_template = """You are voting on the following UN General Assembly resolution:
 
-    ## Simulating International Diplomacy with Large Language Models
+{RESOLUTION_TEXT}
 
-    This is an experimental research project that explores how AI can model international diplomatic behavior.
-    Each of the 195 UN member states is represented by an AI agent with a unique system prompt defining their
-    foreign policy positions, national interests, and diplomatic style.
-    """)
+You must respond with a JSON object containing:
+1. "vote": Your vote - must be exactly one of: "yes", "no", or "abstain"
+2. "statement": A brief statement (2-4 sentences) explaining your country's position
 
-    with gr.Tab("🔬 The Experiment"):
-        gr.Markdown("""
-        ## How It Works
+IMPORTANT: Your statement must articulate {COUNTRY_NAME}'s UNIQUE perspective, national interests, and specific reasons for this vote. Reference your country's:
+- Historical positions on this issue
+- Regional concerns and alliances
+- Domestic political considerations
+- Specific clauses in the resolution that align with or contradict your interests
 
-        ### 1. Agent Architecture
-        Each country is represented by an AI agent powered by **Claude 3.5 Sonnet** (claude-3-5-sonnet-20241022).
-        Every agent receives a unique system prompt that defines:
+Avoid generic diplomatic language. Be specific to {COUNTRY_NAME}'s situation and worldview.
 
-        - **National Identity**: The country they represent and their role
-        - **Core Responsibilities**: How to advocate for their country's interests
-        - **Behavioral Guidelines**: Diplomatic style and historical context
-        - **Key Considerations**: Security, economic, and strategic factors
-        - **Decision Framework**: How to analyze and respond to resolutions
+Your response must be valid JSON in this exact format:
+{
+  "vote": "yes",
+  "statement": "Your explanation here."
+}"""
 
-        ### 2. The System Prompts
-
-        The system prompts are **generic templates** - they do NOT contain country-specific foreign policy positions.
-        Instead, they instruct the AI to:
-        - Draw upon the country's historical positions (from the model's training data)
-        - Consider national security and economic interests
-        - Maintain appropriate diplomatic tone
-        - Think strategically about alliances and precedents
-
-        This means the AI agent must infer each country's likely position based on what it has learned
-        during training about that country's foreign policy, voting patterns, and geopolitical context.
-
-        ### 3. The Process
-
-        1. **Input**: Each agent receives the same UN resolution text
-        2. **Processing**: The agent analyzes how the resolution affects their country's interests
-        3. **Output**: The agent produces a structured JSON response containing:
-           - A vote: YES, NO, or ABSTAIN
-           - A diplomatic statement explaining their position
+# Create Gradio interface
+with gr.Blocks(title="AI Agent UN Experiment", theme=gr.themes.Soft()) as demo:
 
-        ### 4. What This Tests
+    gr.Markdown("""
+    # AI Agent United Nations: Multi-Agent Simulation System
 
-        This experiment explores:
-        - How well LLMs understand different countries' foreign policy positions
-        - Whether AI can model complex geopolitical decision-making
-        - The diversity of perspectives in international relations
-        - Multi-agent AI systems in realistic scenarios
+    ## Modeling International Diplomacy with Structured AI Agents
 
-        ### 5. Important Limitations
+    An experimental framework for simulating UN voting behavior using large language models.
+    Each of 195 UN member states is represented by an AI agent with structured system prompts
+    that must produce constrained JSON outputs for resolutions.
+    """)
 
-        ⚠️ **This is a simulation, not prediction:**
-        - The AI agents' positions are based on historical patterns in training data
-        - They do NOT represent actual government policies or intentions
-        - They should NOT be considered authoritative or predictive
-        - Real diplomacy involves classified information, domestic politics, and human judgment
+    with gr.Tab("System Architecture"):
+        gr.Markdown("""
+        ## System Design
+
+        This is a multi-agent AI system designed to simulate diplomatic decision-making in international forums.
+
+        ### Core Components
+
+        **1. Agent System Prompts**
+        - Each country has a unique system prompt (195 total)
+        - Prompts are generic templates - identical structure for all countries
+        - Only country name and P5 status differ between prompts
+        - No country-specific policy positions are hardcoded
+        - AI must infer positions from training data about each country
+
+        **2. Structured Output Constraints**
+        - All agents must return valid JSON
+        - Strict schema enforcement
+        - Two required fields: `vote` and `statement`
+        - Vote must be one of: `yes`, `no`, `abstain`
+        - Statement must be 2-4 sentences
+
+        **3. Task Running Model**
+        - Python script iterates through all 195 country agents
+        - Each agent receives: system prompt + resolution text + output schema
+        - Agent processes and returns structured JSON response
+        - Results aggregated into single JSON file with metadata
+
+        **4. Model Configuration**
+        - Primary model: Claude 3.5 Sonnet (claude-3-5-sonnet-20241022)
+        - Temperature: 0.7 (balance between consistency and variation)
+        - Max tokens: 800 per response
+        - Provider: Anthropic API (cloud)
+
+        ### What This Tests
+
+        - **LLM Knowledge**: How well models understand different countries' foreign policies
+        - **Structured Outputs**: Ability to consistently produce valid JSON under constraints
+        - **Multi-Agent Systems**: Coordinating 195 independent AI agents
+        - **Prompt Engineering**: Generic templates producing specific behaviors
+        - **Consistency**: Whether similar countries produce similar responses
         """)
 
-    with gr.Tab("📋 System Prompt Explorer"):
+    with gr.Tab("System Prompt Design"):
         gr.Markdown("""
-        ## Explore the Agent System Prompts
+        ## Agent System Prompt Template
+
+        All country agents use the same prompt structure. The AI must infer country-specific positions
+        from its training data about each nation's history, alliances, and interests.
 
-        Select any country to view the exact system prompt their AI agent received.
-        Notice how the prompts are **identical in structure** - the only differences are:
-        - The country name
-        - Whether they're a P5 member (for veto power context)
+        **Template Components:**
 
-        The AI must infer everything else from its training data about each country.
+        1. **Role and Identity** - Defines the country and UN membership status
+        2. **Core Responsibilities** - Instructions to represent national interests
+        3. **Behavioral Guidelines** - How to stay in character diplomatically
+        4. **Key Considerations** - What factors to analyze (security, economics, alliances)
+        5. **Instructions** - Process for evaluating and voting on resolutions
+
+        **View any country's system prompt below:**
         """)
 
         with gr.Row():
@@ -150,11 +176,11 @@ with gr.Blocks(title="AI Agent UN Experiment", theme=gr.themes.Soft()) as demo:
                     value="United States"
                 )
                 gr.Markdown("""
-                ### Try comparing:
-                - **P5 members**: United States, China, Russia, United Kingdom, France
-                - **Regional powers**: Brazil, India, South Africa, Nigeria
-                - **Small states**: Palau, Tuvalu, Monaco
-                - **Key stakeholders**: Israel, Palestine, Egypt, Iran
+                **Compare examples:**
+                - P5 members: United States, China, Russia, United Kingdom, France
+                - Regional powers: Brazil, India, South Africa, Nigeria
+                - Small states: Palau, Tuvalu, Monaco
+                - Key stakeholders: Israel, Palestine, Egypt, Iran
                 """)
 
             with gr.Column(scale=2):
@@ -169,63 +195,155 @@ with gr.Blocks(title="AI Agent UN Experiment", theme=gr.themes.Soft()) as demo:
             outputs=system_prompt_display
         )
 
-    with gr.Tab("📜 The Resolution"):
+    with gr.Tab("Structured Output Schema"):
+        gr.Markdown("""
+        ## JSON Output Constraints
+
+        Every agent must produce a valid JSON response conforming to this schema:
+        """)
+
+        gr.Code(json_schema, language="json", label="Required Output Schema")
+
         gr.Markdown("""
-        ## The Motion Presented to All Agents
+        ### Validation Rules
+
+        **Vote Field:**
+        - Type: String (enum)
+        - Allowed values: `"yes"`, `"no"`, `"abstain"`
+        - Case-insensitive on input, normalized to lowercase
+        - Required field - missing value causes error
+
+        **Statement Field:**
+        - Type: String
+        - Length: 2-4 sentences recommended
+        - Must be country-specific (not generic)
+        - Must reference national interests and historical positions
+        - Required field - missing value causes error
 
-        Every AI agent received this exact same resolution text and was asked to vote on it.
+        ### Error Handling
 
-        **Resolution**: Support for Ceasefire Agreement in Gaza and Commitment to Lasting Peace
+        If an agent produces invalid output:
+        1. JSON parsing attempted with markdown stripping
+        2. If parsing fails: agent recorded as `abstain` with error flag
+        3. If validation fails: agent recorded as `abstain` with error flag
+        4. Error logged for debugging but simulation continues
+
+        ### User Prompt Template
+
+        Below is the exact prompt template sent to each agent (with variables filled in):
         """)
 
-        gr.Markdown(motion_text)
+        gr.Code(user_prompt_template, language="markdown", label="User Prompt Template")
 
-    with gr.Tab("🗳️ Case Study: Gaza Ceasefire"):
+    with gr.Tab("Task Execution"):
         gr.Markdown("""
-        ## Simulation Results
+        ## How Simulations Run
+
+        ### Execution Flow
+
+        ```
+        1. Load motion text from tasks/motions/{motion_id}.md
+        2. Load country list from data/bodies/full-member-states.json
+        3. For each country (195 total):
+           a. Load country's system prompt
+           b. Construct user prompt with motion text
+           c. Send to AI model (system + user prompt)
+           d. Parse and validate JSON response
+           e. Store result with metadata
+        4. Aggregate all responses into single JSON file
+        5. Calculate vote summary statistics
+        6. Save timestamped and "latest" versions
+        ```
+
+        ### Command Line Interface
+
+        **Basic usage:**
+        ```bash
+        python scripts/run_motion.py 01_gaza_ceasefire_resolution
+        ```
+
+        **With options:**
+        ```bash
+        # Use specific model
+        python scripts/run_motion.py 01_gaza_ceasefire_resolution --model claude-3-5-sonnet-20241022
+
+        # Test with sample (5 countries only)
+        python scripts/run_motion.py 01_gaza_ceasefire_resolution --sample 5
+
+        # Use local model (Ollama)
+        python scripts/run_motion.py 01_gaza_ceasefire_resolution --provider local --model llama3
+        ```
+
+        ### Output Format
+
+        Results saved to `tasks/reactions/` as JSON:
+        - `{motion_id}_{timestamp}.json` - Timestamped archive
+        - `{motion_id}_latest.json` - Latest simulation (overwritten)
+
+        **Metadata included:**
+        - `motion_id`: Identifier for the resolution
+        - `timestamp`: ISO 8601 timestamp
+        - `provider`: cloud or local
+        - `model`: Model identifier used
+        - `total_votes`: Number of countries
+        - `vote_summary`: Counts by vote type
+        - `votes`: Array of all country responses
+
+        ### Configuration
+
+        Environment variables (`.env` file):
+        ```
+        ANTHROPIC_API_KEY=your_key_here
+        MODEL_NAME=claude-3-5-sonnet-20241022
+        ```
+        """)
+
+    with gr.Tab("Case Study: Gaza Ceasefire Resolution"):
+        gr.Markdown("""
+        ## Example Simulation Run
 
-        This tab shows the results when all 195 AI country agents voted on the ceasefire resolution.
-        This is ONE example of the experiment in action.
+        This demonstrates the system with a real UN resolution about a Gaza ceasefire.
+        All 195 country agents voted on this resolution using the system described above.
         """)
 
+        gr.Markdown("### The Resolution")
+        gr.Markdown(motion_text)
+
+        gr.Markdown("### Aggregated Results")
+
         with gr.Row():
             with gr.Column():
                 vote_chart = gr.Plot(value=create_vote_summary_chart(data))
 
+            with gr.Column():
                 gr.Markdown(f"""
-                ### Results Summary
-                - **Yes votes:** {data['vote_summary']['yes']} ({data['vote_summary']['yes']/data['total_votes']*100:.1f}%)
-                - **No votes:** {data['vote_summary']['no']} ({data['vote_summary']['no']/data['total_votes']*100:.1f}%)
-                - **Abstentions:** {data['vote_summary']['abstain']} ({data['vote_summary']['abstain']/data['total_votes']*100:.1f}%)
-
-                **Model**: {data['model']}
-                **Date**: {data['timestamp'][:10]}
+                ### Vote Summary
+                - **Yes:** {data['vote_summary']['yes']} ({data['vote_summary']['yes']/data['total_votes']*100:.1f}%)
+                - **No:** {data['vote_summary']['no']} ({data['vote_summary']['no']/data['total_votes']*100:.1f}%)
+                - **Abstain:** {data['vote_summary']['abstain']} ({data['vote_summary']['abstain']/data['total_votes']*100:.1f}%)
+
+                ### Simulation Metadata
+                - **Model:** {data['model']}
+                - **Date:** {data['timestamp'][:10]}
+                - **Countries:** {data['total_votes']}
+                - **Provider:** {data['provider']}
                 """)
 
-    with gr.Tab("🔍 Agent Response Inspector"):
-        gr.Markdown("""
-        ## Compare System Prompt → Agent Response
-
-        Select a country to see:
-        1. The system prompt they received
-        2. The vote and statement they produced
-
-        This shows how the generic prompt + the model's knowledge → specific diplomatic position
-        """)
+        gr.Markdown("### Individual Country Responses")
 
         country_inspector = gr.Dropdown(
             choices=country_names,
-            label="Select Country to Inspect",
+            label="Select Country to View Response",
             value="United States"
         )
 
         with gr.Row():
             with gr.Column():
-                gr.Markdown("### System Prompt Received")
+                gr.Markdown("**System Prompt Received:**")
                 inspector_prompt = gr.Markdown(value=load_system_prompt("united-states"))
 
             with gr.Column():
-                gr.Markdown("### Agent's Response")
+                gr.Markdown("**JSON Output Produced:**")
                 inspector_response = gr.Markdown(value=get_country_response("United States", data)[0])
 
         def update_inspector(country):
@@ -239,8 +357,7 @@ with gr.Blocks(title="AI Agent UN Experiment", theme=gr.themes.Soft()) as demo:
             outputs=[inspector_prompt, inspector_response]
         )
 
-    with gr.Tab("📊 All Responses"):
-        gr.Markdown("### Complete voting record with all diplomatic statements")
+        gr.Markdown("### Complete Response Data")
 
         votes_data = pd.DataFrame([
             {
@@ -262,38 +379,46 @@ with gr.Blocks(title="AI Agent UN Experiment", theme=gr.themes.Soft()) as demo:
     ---
     ## About This Project
 
-    **AI Agent UN** is an experimental research project exploring multi-agent AI systems in international relations contexts.
+    **AI Agent UN** is an experimental framework for simulating international diplomatic decision-making
+    using multi-agent AI systems with structured outputs.
 
-    ### Key Points
+    ### Research Applications
 
-    ✅ **What this is:**
-    - An AI experiment in modeling diplomatic behavior
-    - A research tool for understanding LLM capabilities
-    - An educational demonstration of international relations complexity
+    - Testing LLM knowledge of geopolitics and international relations
+    - Evaluating structured output consistency across hundreds of agents
+    - Studying emergent behavior in multi-agent systems
+    - Educational demonstrations of diplomatic diversity
 
-    ⚠️ **What this is NOT:**
-    - A prediction of actual government positions
-    - An authoritative source on foreign policy
-    - A replacement for real diplomatic analysis
+    ### Technical Implementation
 
-    ### Open Source
+    - **Model:** Claude 3.5 Sonnet (claude-3-5-sonnet-20241022)
+    - **Agents:** 195 (one per UN member state)
+    - **System Prompts:** Generic templates (country-agnostic)
+    - **Output Format:** Structured JSON with validation
+    - **Execution:** Python CLI with parallel processing support
+    - **Storage:** JSON files with metadata
 
-    This project is open source. All system prompts, code, and simulation results are available on GitHub.
+    ### Limitations and Disclaimers
 
-    - 📂 [GitHub Repository](https://github.com/danielrosehill/AI-Agent-UN)
-    - 📖 [Documentation](https://github.com/danielrosehill/AI-Agent-UN/blob/main/README.md)
-    - 🤖 [Agent Prompts](https://github.com/danielrosehill/AI-Agent-UN/tree/main/agents/representatives)
+    This is a simulation for research and educational purposes:
+    - AI positions are based on training data, not actual policies
+    - Does NOT predict real government decisions
+    - Should NOT be considered authoritative
+    - Real diplomacy involves classified intel and human judgment
+    - Training data may be outdated or incomplete
+
+    ### Open Source
 
-    ### Technical Details
+    All code, prompts, and data are open source:
 
-    - **Model**: Claude 3.5 Sonnet (claude-3-5-sonnet-20241022)
-    - **Countries**: 195 UN member states
-    - **Output Format**: Structured JSON (vote + statement)
-    - **System Prompts**: Generic templates (no country-specific policies hardcoded)
+    - GitHub Repository: https://github.com/danielrosehill/AI-Agent-UN
+    - System Prompts: https://github.com/danielrosehill/AI-Agent-UN/tree/main/agents/representatives
+    - Execution Script: https://github.com/danielrosehill/AI-Agent-UN/blob/main/scripts/run_motion.py
+    - Documentation: https://github.com/danielrosehill/AI-Agent-UN/blob/main/README.md
 
     ---
 
-    *Built with [Gradio](https://gradio.app) | Powered by [Anthropic Claude](https://anthropic.com/claude)*
+    Built with Gradio | Powered by Anthropic Claude
     """)
 
 if __name__ == "__main__":