analyze-results

name	analyze-results
description	Analyze EDSL Results objects - load by UUID or file path, export survey documentation, and generate analysis reports
allowed-tools	Read, Glob, Bash(python:*), Bash(pandoc *), Write, AskUserQuestion
user-invocable	true
arguments	UUID or path to results.json.gz file

Analyze EDSL Results

Load an EDSL Results object from Expected Parrot (by UUID) or from a local file (results.json.gz), export documentation files, and generate a comprehensive analysis report.

Usage

/edsl-analyze-results <uuid-or-path>

Examples:

/edsl-analyze-results 123e4567-e89b-12d3-a456-426614174000
/edsl-analyze-results ./my_experiment/results.json.gz

After loading the results, the skill will ask you to choose an analysis focus (full analysis, summary statistics, cross-tabulation, or a specific custom focus).

IMPORTANT: Always ask this question, even if the user provided a query with the UUID. The question helps clarify what type of analysis they want. If they select "Specific focus", follow up to get their specific question or hypothesis.

Workflow

1. Parse the Input

Determine if the input is:

• UUID: A 36-character UUID (e.g., 123e4567-e89b-12d3-a456-426614174000)
• File path: A path ending in .json.gz or .json

If unclear, use AskUserQuestion to clarify.

2. Load the Results

from edsl import Results

# Load by UUID (from Expected Parrot cloud)
results = Results.pull("123e4567-e89b-12d3-a456-426614174000")

# OR load from local file
results = Results.load("path/to/results")  # .json.gz extension optional

3. Create Output Directory and Ask about Report Focus

Create a directory for the analysis outputs using sequential numbering:

import os
import glob

# Find existing analysis directories and get next number
existing = glob.glob("./analysis_*")
existing_nums = []
for d in existing:
    try:
        num = int(d.split("_")[-1])
        existing_nums.append(num)
    except ValueError:
        pass

next_num = max(existing_nums, default=0) + 1
output_dir = f"./analysis_{next_num}"
os.makedirs(output_dir, exist_ok=True)

always use AskUserQuestion to ask about the analysis focus. This ensures the report is tailored to the user's needs. It's a free text question:

Question: "What would you like me to focus on in the analysis?"
Header: "Focus"

4. Export Documentation Files

Export three core documentation files:

# Get survey from results
survey = results.survey

# 1. Export survey as markdown
survey_md = survey.to_markdown()
with open(f"{output_dir}/survey.md", "w") as f:
    f.write(survey_md)

# 2. Export survey as mermaid diagram
# Note: Sanitize HTML tags for mermaid v11+ compatibility
import re
survey_mermaid = survey.to_mermaid()
# Remove HTML tags that cause syntax errors in newer mermaid versions
survey_mermaid = re.sub(r'<b>|</b>|<br/>', '\n', survey_mermaid)
survey_mermaid = re.sub(r'\n+', '\n', survey_mermaid)  # Clean up multiple newlines
with open(f"{output_dir}/survey.mermaid", "w") as f:
    f.write(survey_mermaid)

# 3. Export results as CSV
results_csv = results.to_csv()
results_csv.write(f"{output_dir}/results.csv")
# OR: with open(f"{output_dir}/results.csv", "w") as f: f.write(results_csv.text)

5. Initial Data Exploration

Before analysis, explore the data structure:

import pandas as pd

# Load and examine the CSV
df = pd.read_csv(f"{output_dir}/results.csv")

# Get column info
print(f"Shape: {df.shape}")
print(f"Columns: {list(df.columns)}")

# Identify question answer columns (answer.*)
answer_cols = [c for c in df.columns if c.startswith('answer.')]
print(f"Answer columns: {answer_cols}")

# Identify agent columns (agent.*)
agent_cols = [c for c in df.columns if c.startswith('agent.')]
print(f"Agent columns: {agent_cols}")

# Identify scenario columns (scenario.*)
scenario_cols = [c for c in df.columns if c.startswith('scenario.')]
print(f"Scenario columns: {scenario_cols}")

# Identify question text columns (question_text.*)
question_text_cols = [c for c in df.columns if c.startswith('question_text.')]
print(f"Question text columns: {question_text_cols}")

# Identify question option columns (question_options.*)
question_options_cols = [c for c in df.columns  c.startswith()]
()


question_type_cols = [c  c  df.columns  c.startswith()]
()

6. Generate Analysis Report

Create a comprehensive report.md with:

Structure

# Results Analysis Report

## Study Design

### Questions

[For EACH question in the survey, show:]

#### Q1: [question_name] ([question_type])

**Template:** [The raw question template text from question_text.* column]

**Options:** [The options from question_options.* column, if applicable]

**Realized versions:**

[If the question uses scenario variables (Jinja2 templates like {{ var }}), show a table
of ALL unique realized question texts across scenario conditions. Group by scenario
variables to show what each condition looked like.]

| Scenario Condition | Realized Question Text |
|--------------------|----------------------|
| [condition 1]      | [full realized text] |
| [condition 2]      | [full realized text] |
...

[Repeat for each question]

### Scenario Variables

[Show ALL scenario variables and their unique values]

| Variable | Unique Values |
|----------|--------------|
| scenario.domain | health_insurance, software_platform, ... |
| scenario.framing | neutral, status_quo |
...

### Scenario Matrix

[Show the full crossing of scenario variables as a table, so the reader can see
every unique experimental condition. Include the count of observations per cell.]

### Agents / Models

[Show the models or agents used, their configuration (temperature, etc.),
and how many responses each produced]

## Data Summary
- Number of responses: N
- Agent traits collected: [list]
- Scenarios tested: [list]

## Detailed Results

### Q1: [Question Name]
[Response distribution table]
![Question 1 visualization](q1_distribution.png)
[Interpretation of results]

### Q2: [Question Name]
[Same pattern - table, visualization, interpretation together]

## Key Findings
[Main insights from the data]

## Cross-Tabulations (if applicable)
[Relationships between variables - only include agent breakdowns if agents have meaningful names, not UUIDs]

## Files Generated

| File | Description |
|------|-------------|
| [survey.md](survey.md) | Survey documentation |
| [survey.mermaid](survey.mermaid) | Survey flow diagram |
| [results.csv](results.csv) | Raw results data |
| [report.html](report.html) | This report (HTML) |

Generating the Study Design Section

The Study Design section is critical — it should make the report self-contained so a reader understands exactly what was asked without needing to open separate files.

For each question, extract the realized text from the data:

# Get unique realized question texts per scenario condition
for qt_col in question_text_cols:
    q_name = qt_col.replace('question_text.', '').replace('_question_text', '')
    template = df[qt_col].iloc[0]  # Template text (may have {{ var }} syntax)

    # Check if question uses scenario variables by looking at prompt columns
    # The actual realized text (with scenarios filled in) is in the prompt.* columns
    prompt_col = f'prompt.{q_name}_user_prompt'
    if prompt_col in df.columns:
        # Extract unique realized prompts grouped by scenario conditions
        if scenario_cols:
            # Group by scenario variables to show each condition
            groups = df.groupby([c for c in scenario_cols if df[c].nunique() > 1])
            for name, group in groups:
                realized_text = group[prompt_col].iloc[0]
                # Include in report table

For scenario variables, enumerate all unique values:

for col in scenario_cols:
    unique_vals = df[col].dropna().unique()
    # Show variable name (without 'scenario.' prefix) and all its values

For the scenario matrix, show the full experimental design:

# Cross-tabulate scenario variables to show the design
if len(scenario_cols) >= 2:
    # Pick the most meaningful scenario columns (skip index/id columns)
    meaningful_scenario_cols = [c for c in scenario_cols
                                 if not c.endswith('_index') and not c.endswith('_id')]
    # Show unique combinations and observation counts
    design = df.groupby(meaningful_scenario_cols).size().reset_index(name='n_observations')

IMPORTANT: When listing files in the report, always use relative hyperlinks (e.g., [survey.md](survey.md)) so users can click through to the files.

IMPORTANT:

• Do NOT include mermaid diagrams in the report (they often don't render correctly in HTML output). The mermaid file is still exported separately for reference.
• Only include per-agent analysis if agents have meaningful names (not UUIDs). Check if agent names look like UUIDs (36-character strings with hyphens in pattern 8-4-4-4-12) and skip agent breakdowns if so.

IMPORTANT: Place each visualization immediately after its corresponding question's data table, not in a separate section at the end. This keeps the analysis coherent and easy to follow.

Generate Visualizations (Inline with Questions)

For each question, generate and save a visualization, then reference it in the report immediately after the question's statistics:

import matplotlib.pyplot as plt

# For each question, generate chart and include in report immediately
for col in answer_cols:
    question_name = col.replace('answer.', '')
    value_counts = df[col].value_counts()

    # Add question section to report
    report += f"### {question_name}\n\n"
    report += "[Response distribution table here]\n\n"

    # Generate and save chart
    if len(value_counts) <= 20:
        fig, ax = plt.subplots(figsize=(10, 6))
        value_counts.plot(kind='bar', ax=ax)
        ax.set_title(f'Response Distribution: {question_name}')
        ax.set_xlabel('Response')
        ax.set_ylabel('Count')
        plt.tight_layout()
        chart_path = f"{question_name}_distribution.png"
        plt.savefig(f'{output_dir}/{chart_path}', dpi=150)
        plt.close()

        # Include chart immediately after question data
        report += f"![{question_name} distribution]({chart_path})\n\n"

    report += "[Interpretation of this question's results]\n\n"

7. Save All Outputs

Ensure all files are saved to the output directory:

output_dir/
├── survey.md          # Survey in markdown format
├── survey.mermaid     # Survey flow diagram
├── results.csv        # Full results data
├── report.md          # Analysis report
├── report.html        # Styled HTML report
├── *.png              # Visualization files
└── analysis.py        # Optional: reproducible analysis script

8. Generate HTML Report with Pandoc

After saving report.md, convert it to a styled HTML report using pandoc:

# CSS file location
CSS_FILE="$HOME/tools/ep/skills/assets/report.css"

# Generate HTML report (no --metadata title to avoid duplicate with markdown h1)
pandoc "${output_dir}/report.md" \
    -o "${output_dir}/report.html" \
    --css="${CSS_FILE}" \
    --standalone

Or in Python:

import subprocess
import os

css_file = os.path.expanduser("~/tools/ep/skills/assets/report.css")
# Note: Don't use --metadata title= since report.md already has # heading
subprocess.run([
    "pandoc",
    f"{output_dir}/report.md",
    "-o", f"{output_dir}/report.html",
    f"--css={css_file}",
    "--standalone"
], check=True)
print(f"Generated: {output_dir}/report.html")

Note: The mermaid diagram is exported separately as survey.mermaid but not embedded in the report due to rendering issues in HTML output.

Complete Example Script

"""
EDSL Results Analysis Script
"""
from edsl import Results
import pandas as pd
import matplotlib.pyplot as plt
import os
import re
from datetime import datetime

# === CONFIGURATION ===
# Modify this to load your results
RESULTS_UUID = "123e4567-e89b-12d3-a456-426614174000"  # Or use file path
# RESULTS_PATH = "./results.json.gz"

# === LOAD RESULTS ===
results = Results.pull(RESULTS_UUID)
# results = Results.load(RESULTS_PATH)

# === CREATE OUTPUT DIRECTORY ===
import glob
existing = glob.glob("./analysis_*")
existing_nums = []
for d in existing:
    try:
        num = int(d.split("_")[-1])
        existing_nums.append(num)
    except ValueError:
        pass
next_num = max(existing_nums, default=0) + 1
output_dir = f"./analysis_{next_num}"
os.makedirs(output_dir, exist_ok=True)

# === EXPORT DOCUMENTATION ===
survey = results.survey

# Survey markdown
with open(f"{output_dir}/survey.md", "w") as f:
    f.write(survey.to_markdown())

# Survey mermaid (sanitize HTML tags for mermaid v11+ compatibility)
survey_mermaid = survey.to_mermaid()
survey_mermaid = re.sub(, , survey_mermaid)
survey_mermaid = re.sub(, , survey_mermaid)
 (, )  f:
    f.write(survey_mermaid)


results_csv = results.to_csv()
results_csv.write()


df = pd.read_csv()


answer_cols = [c  c  df.columns  c.startswith()]
agent_cols = [c  c  df.columns  c.startswith()]
scenario_cols = [c  c  df.columns  c.startswith()]


 re
 ():
    
      (s, ):
         
    uuid_pattern = 
     (re.(uuid_pattern, s.lower()))


has_meaningful_agents = 
   df.columns:
    agent_names = df[].dropna().unique()
    has_meaningful_agents = (agent_names) >    (is_uuid((name))  name  agent_names)



question_text_cols = [c  c  df.columns  c.startswith()]
question_options_cols = [c  c  df.columns  c.startswith()]
question_type_cols = [c  c  df.columns  c.startswith()]
prompt_cols = [c  c  df.columns  c.startswith()  c.endswith()]
model_cols = [c  c  df.columns  c.startswith()]

study_design = 


study_design += 

 qt_col  question_text_cols:
    q_name = qt_col.replace(, ).replace(, )
    template = (df[qt_col].iloc[])

    
    qt_type_col = 
    q_type = (df[qt_type_col].iloc[])  qt_type_col  df.columns  

    
    qo_col = 
    q_options = (df[qo_col].iloc[])  qo_col  df.columns  df[qo_col].notna().()  

    study_design += 
    study_design += 
     q_options  q_options != :
        study_design += 

    
    
    prompt_col = 
     prompt_col  df.columns  scenario_cols:
        meaningful_scenario_cols = [c  c  scenario_cols
                                       c.endswith()  df[c].nunique() > ]
         meaningful_scenario_cols:
            
            unique_prompts = df.groupby(meaningful_scenario_cols)[prompt_col].first().reset_index()
             (unique_prompts) > :  
                study_design += 
                study_design +=  + .join(c.replace(, )  c  meaningful_scenario_cols) + 
                study_design +=  + .join(  _  meaningful_scenario_cols) + 
                 _, row  unique_prompts.iterrows():
                    conditions = .join((row[c])  c  meaningful_scenario_cols)
                    
                    prompt_text = (row[prompt_col]).replace(, ).replace(, )
                     (prompt_text) > :
                        prompt_text = prompt_text[:] + 
                    study_design += 
                study_design += 

    study_design += 


 scenario_cols:
    study_design += 
    study_design += 
    study_design += 
     col  scenario_cols:
          col.endswith():
            unique_vals = df[col].dropna().unique()
            vals_str = .join((v)  v  (unique_vals, key=))
             (vals_str) > :
                vals_str = vals_str[:] + 
            study_design += 
    study_design += 

    
    meaningful_scenario_cols = [c  c  scenario_cols
                                   c.endswith()   c.endswith()  df[c].nunique() > ]
     (meaningful_scenario_cols) >= :
        study_design += 
        design_matrix = df.groupby(meaningful_scenario_cols).size().reset_index(name=)
        study_design += design_matrix.to_markdown(index=) + 


study_design += 
   df.columns:
    model_info = df.groupby().size().reset_index(name=)
    study_design += 
    study_design += 
     _, row  model_info.iterrows():
        study_design += 
    study_design += 
    
    config_cols = [c  c  model_cols  c   [, ]  df[c].nunique() == ]
     config_cols:
        study_design += 
        configs = [  c  config_cols]
        study_design += .join(configs) + 

 has_meaningful_agents:
    agent_info = df.groupby().size().reset_index(name=)
    study_design += 
    study_design += 
     _, row  agent_info.iterrows():
        study_design += 
    study_design += 


report = 


 col  answer_cols:
    question_name = col.replace(, )
    value_counts = df[col].value_counts()

    report += 
    report += 
    report += 
     val, count  value_counts.items():
        pct = count / (df) * 
        report += 
    report += 

    
     (value_counts) <= :  
        fig, ax = plt.subplots(figsize=(, ))
        value_counts.plot(kind=, ax=ax)
        ax.set_title()
        ax.set_xlabel()
        ax.set_ylabel()
        plt.xticks(rotation=, ha=)
        plt.tight_layout()
        chart_path = 
        plt.savefig(, dpi=)
        plt.close()
        report += 


 has_meaningful_agents:
    report += 
    
     col  answer_cols:
        question_name = col.replace(, )
        crosstab = pd.crosstab(df[], df[col], normalize=) * 
        report += 
        report += crosstab.to_markdown() + 

report += 


 (, )  f:
    f.write(report)


 subprocess
css_file = os.path.expanduser()
subprocess.run([
    ,
    ,
    , ,
    ,
    
], check=)

()
()
()
()
()
()

9. Ask about PowerPoint

Use the AskUserQuestion if they'd like a PPTX slideshow as well. If they say yes, create a PPTX file for them based on the report.md

• Question: Would you like a Power Point version of the results? -Options: Yes/No

Output Files

File	Description
survey.md	Human-readable survey documentation with questions, options, and rules
survey.mermaid	Mermaid diagram showing survey flow and skip logic
results.csv	Full results data in CSV format for analysis
report.md	Comprehensive analysis report with findings and visualizations
report.html	Styled HTML report (via pandoc with Expected Parrot CSS)
*.png	Charts and visualizations referenced in the report
analysis.py	(Optional) Reproducible Python script for the analysis

Output options

Tips

• Check survey.mermaid separately to understand skip logic before analyzing
• Look for patterns in agent traits vs. responses (only if agents have meaningful names, not UUIDs)
• Compare responses across scenarios (if scenarios were used)
• The answer.* columns contain question responses
• The agent.* columns contain agent trait values
• The scenario.* columns contain scenario variable values
• Use comment.* columns to see free-text explanations (if available)
• Per-agent breakdowns are automatically skipped when agent names are UUIDs (not meaningful for analysis)

Common Analysis Patterns

Cross-tabulation by Scenario

# Compare responses across scenarios
pd.crosstab(df['scenario.condition'], df['answer.question_name'], normalize='index')

Agent Trait Analysis

# First check if agents have meaningful names (not UUIDs)
import re
def is_uuid(s):
    uuid_pattern = r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
    return bool(re.match(uuid_pattern, str(s).lower()))

# Only analyze by agent if names are meaningful
if not all(is_uuid(name) for name in df['agent.agent_name'].dropna().unique()):
    df.groupby('agent.agent_name')['answer.question_name'].value_counts(normalize=True)

Response Correlation

# For numeric responses
df[[c for c in answer_cols if df[c].dtype in ['int64', 'float64']]].corr()