AINativeBench / data /processed /RQ3 /analyze_agent_time_comparisons.py

王子睿

restructure + add files

8c10cf2 11 months ago

20.1 kB

#!/usr/bin/env python3
"""
Agent-Level Time Comparison Analysis Script
This script analyzes agent time data from Part2 directories, comparing:
- MCP vs Hardcoded
- MCP vs A2A
- A2A vs A2A_mix
For each comparison, it shows:
- Agent time proportions (percentage of total time)
- Actual agent times (mean time per occurrence)
- Differences in both absolute and percentage terms
"""

import csv
import re
from pathlib import Path
from collections import defaultdict
from typing import Dict, List, Tuple, Optional
import logging

# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
)
logger = logging.getLogger(__name__)


def parse_agent_map(agent_map_path: Path) -> Dict[str, str]:
    """
    Parse agent_map.md file to extract agent name mappings.
    Format example:
    --agent-map "Expert SQL Query Generator:SQL Query Generator"
    Returns:
        Dict mapping original name -> standardized name
    """
    agent_map = {}

    if not agent_map_path.exists():
        logger.warning(f"Agent map not found: {agent_map_path}")
        return agent_map

    try:
        with open(agent_map_path, "r", encoding="utf-8") as f:
            content = f.read()

        # Pattern to match --agent-map "Original Name:Standardized Name"
        pattern = r'--agent-map\s+"([^:]+):([^"]+)"'
        matches = re.findall(pattern, content)

        for original, standardized in matches:
            agent_map[original.strip()] = standardized.strip()

        logger.info(f"Loaded {len(agent_map)} agent mappings from {agent_map_path}")
    except Exception as e:
        logger.error(f"Failed to parse agent map {agent_map_path}: {e}")

    return agent_map


def load_agent_time_data(
    csv_path: Path, agent_map: Dict[str, str]
) -> Dict[str, Dict[str, float]]:
    """
    Load agent time data from agent_llm_tool_breakdown_by_model.csv.
    Returns:
        Dict[model][agent] = {
            'mean_time': mean time per occurrence in seconds,
            'total_time': total time in seconds,
            'occurrences': number of occurrences
        }
    """
    agent_data = defaultdict(lambda: defaultdict(dict))

    if not csv_path.exists():
        logger.warning(f"CSV file not found: {csv_path}")
        return agent_data

    try:
        with open(csv_path, "r", encoding="utf-8") as f:
            reader = csv.DictReader(f)
            for row in reader:
                model = row["model"]
                agent_name = row["agent_name"]

                # Apply agent name mapping if available
                standardized_name = agent_map.get(agent_name, agent_name)

                occurrences = int(row["occurrences"])
                total_time_ms = float(row["total_agent_llm_tool_time_ms"])
                total_time_s = total_time_ms / 1000.0  # Convert to seconds

                mean_time = total_time_s / occurrences if occurrences > 0 else 0

                agent_data[model][standardized_name] = {
                    "mean_time": mean_time,
                    "total_time": total_time_s,
                    "occurrences": occurrences,
                }

        logger.info(f"Loaded agent data from {csv_path}")
    except Exception as e:
        logger.error(f"Failed to load agent data from {csv_path}: {e}")

    return agent_data


def calculate_agent_proportions(
    agent_data: Dict[str, Dict[str, float]],
) -> Dict[str, Dict[str, float]]:
    """
    Calculate what proportion of total time each agent takes per model.
    Returns:
        Dict[model][agent] = proportion (0-1)
    """
    proportions = defaultdict(dict)

    for model, agents in agent_data.items():
        # Calculate total time across all agents for this model
        total_time = sum(data["total_time"] for data in agents.values())

        if total_time > 0:
            for agent, data in agents.items():
                proportions[model][agent] = data["total_time"] / total_time
        else:
            for agent in agents.keys():
                proportions[model][agent] = 0.0

    return proportions


def generate_project_comparison(
    project_name: str,
    version_a_suffix: str,
    version_b_suffix: str,
    part2_dir: Path,
    version_a_name: str,
    version_b_name: str,
) -> str:
    """Generate agent-level comparison for a single project, organized by agent."""
    lines = []
    lines.append(f"# {project_name}: {version_a_name} vs {version_b_name}\n\n")

    # Get paths
    scenario_a = f"{project_name}{version_a_suffix}"
    scenario_b = f"{project_name}{version_b_suffix}"

    dir_a = part2_dir / scenario_a
    dir_b = part2_dir / scenario_b

    if not dir_a.exists() or not dir_b.exists():
        lines.append("_Data not available for comparison_\n\n")
        return "".join(lines)

    # Load agent maps
    map_a = parse_agent_map(dir_a / "agent_map.md")
    map_b = parse_agent_map(dir_b / "agent_map.md")

    # Load agent data
    data_a = load_agent_time_data(
        dir_a / "agent_llm_tool_breakdown_by_model.csv", map_a
    )
    data_b = load_agent_time_data(
        dir_b / "agent_llm_tool_breakdown_by_model.csv", map_b
    )

    if not data_a or not data_b:
        lines.append("_No agent data available_\n\n")
        return "".join(lines)

    # Calculate proportions
    prop_a = calculate_agent_proportions(data_a)
    prop_b = calculate_agent_proportions(data_b)

    # Get all models and agents
    all_models = sorted(set(data_a.keys()) | set(data_b.keys()))

    # Get all unique agents across all models
    all_agents = set()
    for model in all_models:
        all_agents.update(data_a.get(model, {}).keys())
        all_agents.update(data_b.get(model, {}).keys())
    all_agents = sorted(all_agents)

    # Organize by agent
    for agent in all_agents:
        lines.append(f"## Agent: {agent}\n\n")

        # Per-model comparison for this agent
        lines.append(f"### Per-Model Comparison\n\n")
        lines.append(
            f"| Model | {version_a_name} Time (s) | {version_b_name} Time (s) | Time Diff | "
        )
        lines.append(f"{version_a_name} % | {version_b_name} % | Proportion Diff |\n")
        lines.append("| --- | --- | --- | --- | --- | --- | --- |\n")

        # Collect data for overall average
        overall_time_a = []
        overall_time_b = []
        overall_prop_a = []
        overall_prop_b = []

        for model in all_models:
            data_a_agent = data_a.get(model, {}).get(
                agent, {"mean_time": 0, "total_time": 0}
            )
            data_b_agent = data_b.get(model, {}).get(
                agent, {"mean_time": 0, "total_time": 0}
            )

            time_a = data_a_agent["mean_time"]
            time_b = data_b_agent["mean_time"]

            # Skip if both are 0 (agent not present in this model)
            if time_a == 0 and time_b == 0:
                continue

            prop_a_val = prop_a.get(model, {}).get(agent, 0) * 100
            prop_b_val = prop_b.get(model, {}).get(agent, 0) * 100

            time_diff = time_a - time_b
            time_pct = (time_diff / time_b * 100) if time_b > 0 else 0

            prop_diff = prop_a_val - prop_b_val

            lines.append(
                f"| {model} | {time_a:.2f} | {time_b:.2f} | "
                f"{time_diff:+.2f}s ({time_pct:+.1f}%) | "
                f"{prop_a_val:.1f}% | {prop_b_val:.1f}% | "
                f"{prop_diff:+.1f}pp |\n"
            )

            # Collect for average
            if time_a > 0:
                overall_time_a.append(time_a)
                overall_prop_a.append(prop_a_val)
            if time_b > 0:
                overall_time_b.append(time_b)
                overall_prop_b.append(prop_b_val)

        lines.append("\n")

        # Overall average for this agent across all models
        if overall_time_a or overall_time_b:
            lines.append(f"### Overall Average Across All Models\n\n")
            lines.append(
                f"| Metric | {version_a_name} | {version_b_name} | Difference |\n"
            )
            lines.append("| --- | --- | --- | --- |\n")

            avg_time_a = (
                sum(overall_time_a) / len(overall_time_a) if overall_time_a else 0
            )
            avg_time_b = (
                sum(overall_time_b) / len(overall_time_b) if overall_time_b else 0
            )
            avg_prop_a = (
                sum(overall_prop_a) / len(overall_prop_a) if overall_prop_a else 0
            )
            avg_prop_b = (
                sum(overall_prop_b) / len(overall_prop_b) if overall_prop_b else 0
            )

            time_diff_avg = avg_time_a - avg_time_b
            time_pct_avg = (time_diff_avg / avg_time_b * 100) if avg_time_b > 0 else 0
            prop_diff_avg = avg_prop_a - avg_prop_b

            lines.append(
                f"| Mean Time (s) | {avg_time_a:.2f} | {avg_time_b:.2f} | "
                f"{time_diff_avg:+.2f}s ({time_pct_avg:+.1f}%) |\n"
            )
            lines.append(
                f"| Time Proportion (%) | {avg_prop_a:.1f}% | {avg_prop_b:.1f}% | "
                f"{prop_diff_avg:+.1f}pp |\n"
            )
            lines.append("\n")

        lines.append("---\n\n")

    return "".join(lines)


def generate_overall_comparison(
    projects: List[str],
    version_a_suffix: str,
    version_b_suffix: str,
    part2_dir: Path,
    version_a_name: str,
    version_b_name: str,
    comparison_title: str,
) -> str:
    """Generate overall agent-level comparison across multiple projects."""
    lines = []
    lines.append(f"# Overall {comparison_title}\n\n")
    lines.append(f"Averaged across all projects: {', '.join(projects)}\n\n")

    # Collect data from all projects
    overall_data_a = defaultdict(
        lambda: defaultdict(lambda: {"total_time": 0, "count": 0})
    )
    overall_data_b = defaultdict(
        lambda: defaultdict(lambda: {"total_time": 0, "count": 0})
    )

    for project in projects:
        scenario_a = f"{project}{version_a_suffix}"
        scenario_b = f"{project}{version_b_suffix}"

        dir_a = part2_dir / scenario_a
        dir_b = part2_dir / scenario_b

        if not dir_a.exists() or not dir_b.exists():
            continue

        # Load agent maps
        map_a = parse_agent_map(dir_a / "agent_map.md")
        map_b = parse_agent_map(dir_b / "agent_map.md")

        # Load agent data
        data_a = load_agent_time_data(
            dir_a / "agent_llm_tool_breakdown_by_model.csv", map_a
        )
        data_b = load_agent_time_data(
            dir_b / "agent_llm_tool_breakdown_by_model.csv", map_b
        )

        # Calculate proportions
        prop_a = calculate_agent_proportions(data_a)
        prop_b = calculate_agent_proportions(data_b)

        # Aggregate data
        for model, agents in data_a.items():
            for agent, agent_data in agents.items():
                overall_data_a[model][agent]["total_time"] += agent_data["total_time"]
                overall_data_a[model][agent]["count"] += agent_data["occurrences"]

        for model, agents in data_b.items():
            for agent, agent_data in agents.items():
                overall_data_b[model][agent]["total_time"] += agent_data["total_time"]
                overall_data_b[model][agent]["count"] += agent_data["occurrences"]

    # Calculate overall proportions and means
    all_models = sorted(set(overall_data_a.keys()) | set(overall_data_b.keys()))

    for model in all_models:
        lines.append(f"## {model}\n\n")

        agents_a = set(overall_data_a[model].keys())
        agents_b = set(overall_data_b[model].keys())
        all_agents = sorted(agents_a | agents_b)

        if not all_agents:
            lines.append("_No agent data for this model_\n\n")
            continue

        # Calculate total time for proportions
        total_time_a = sum(d["total_time"] for d in overall_data_a[model].values())
        total_time_b = sum(d["total_time"] for d in overall_data_b[model].values())

        # Table header
        lines.append(
            f"| Agent | {version_a_name} Mean (s) | {version_b_name} Mean (s) | Time Diff | "
        )
        lines.append(f"{version_a_name} % | {version_b_name} % | Proportion Diff |\n")
        lines.append("| --- | --- | --- | --- | --- | --- | --- |\n")

        for agent in all_agents:
            data_a = overall_data_a[model][agent]
            data_b = overall_data_b[model][agent]

            mean_a = (
                data_a["total_time"] / data_a["count"] if data_a["count"] > 0 else 0
            )
            mean_b = (
                data_b["total_time"] / data_b["count"] if data_b["count"] > 0 else 0
            )

            prop_a = (
                (data_a["total_time"] / total_time_a * 100) if total_time_a > 0 else 0
            )
            prop_b = (
                (data_b["total_time"] / total_time_b * 100) if total_time_b > 0 else 0
            )

            time_diff = mean_a - mean_b
            time_pct = (time_diff / mean_b * 100) if mean_b > 0 else 0

            prop_diff = prop_a - prop_b

            lines.append(
                f"| {agent} | {mean_a:.2f} | {mean_b:.2f} | "
                f"{time_diff:+.2f}s ({time_pct:+.1f}%) | "
                f"{prop_a:.1f}% | {prop_b:.1f}% | "
                f"{prop_diff:+.1f}pp |\n"
            )
    return "".join(lines)


def generate_overall_summary(
    projects: List[str],
    version_a_suffix: str,
    version_b_suffix: str,
    part2_dir: Path,
    version_a_name: str,
    version_b_name: str,
) -> str:
    """Generate overall summary across all projects and models."""
    lines = []
    lines.append("## Overall Summary (All Projects, All Models)\n\n")

    # Collect data from all projects
    overall_data_a = defaultdict(lambda: {"total_time": 0, "count": 0})
    overall_data_b = defaultdict(lambda: {"total_time": 0, "count": 0})

    for project in projects:
        scenario_a = f"{project}{version_a_suffix}"
        scenario_b = f"{project}{version_b_suffix}"

        dir_a = part2_dir / scenario_a
        dir_b = part2_dir / scenario_b

        if not dir_a.exists() or not dir_b.exists():
            continue

        # Load agent maps
        map_a = parse_agent_map(dir_a / "agent_map.md")
        map_b = parse_agent_map(dir_b / "agent_map.md")

        # Load agent data
        data_a = load_agent_time_data(
            dir_a / "agent_llm_tool_breakdown_by_model.csv", map_a
        )
        data_b = load_agent_time_data(
            dir_b / "agent_llm_tool_breakdown_by_model.csv", map_b
        )

        # Aggregate data across all models
        for model, agents in data_a.items():
            for agent, agent_data in agents.items():
                overall_data_a[agent]["total_time"] += agent_data["total_time"]
                overall_data_a[agent]["count"] += agent_data["occurrences"]

        for model, agents in data_b.items():
            for agent, agent_data in agents.items():
                overall_data_b[agent]["total_time"] += agent_data["total_time"]
                overall_data_b[agent]["count"] += agent_data["occurrences"]

    # Get all agents
    all_agents = sorted(set(overall_data_a.keys()) | set(overall_data_b.keys()))

    if not all_agents:
        lines.append("_No data available_\n\n")
        return "".join(lines)

    # Calculate total time for proportions
    total_time_a = sum(d["total_time"] for d in overall_data_a.values())
    total_time_b = sum(d["total_time"] for d in overall_data_b.values())

    # Table header
    lines.append(
        f"| Agent | {version_a_name} Mean (s) | {version_b_name} Mean (s) | Time Diff | "
    )
    lines.append(f"{version_a_name} % | {version_b_name} % | Proportion Diff |\n")
    lines.append("| --- | --- | --- | --- | --- | --- | --- |\n")

    for agent in all_agents:
        data_a = overall_data_a[agent]
        data_b = overall_data_b[agent]

        mean_a = data_a["total_time"] / data_a["count"] if data_a["count"] > 0 else 0
        mean_b = data_b["total_time"] / data_b["count"] if data_b["count"] > 0 else 0

        prop_a = (data_a["total_time"] / total_time_a * 100) if total_time_a > 0 else 0
        prop_b = (data_b["total_time"] / total_time_b * 100) if total_time_b > 0 else 0

        time_diff = mean_a - mean_b
        time_pct = (time_diff / mean_b * 100) if mean_b > 0 else 0

        prop_diff = prop_a - prop_b

        lines.append(
            f"| {agent} | {mean_a:.2f} | {mean_b:.2f} | "
            f"{time_diff:+.2f}s ({time_pct:+.1f}%) | "
            f"{prop_a:.1f}% | {prop_b:.1f}% | "
            f"{prop_diff:+.1f}pp |\n"
        )

    lines.append("\n---\n\n")
    return "".join(lines)


def generate_comparisons_for_projects(
    projects: List[str],
    version_a_suffix: str,
    version_b_suffix: str,
    part2_dir: Path,
    version_a_name: str,
    version_b_name: str,
    comparison_title: str,
) -> str:
    """Generate project-by-project agent-level comparisons."""
    lines = []
    lines.append(f"# {comparison_title}\n\n")
    lines.append(f"Projects included: {', '.join(projects)}\n\n")
    lines.append("---\n\n")

    # Add overall summary first
    overall_summary = generate_overall_summary(
        projects,
        version_a_suffix,
        version_b_suffix,
        part2_dir,
        version_a_name,
        version_b_name,
    )
    lines.append(overall_summary)

    # Generate comparison for each project
    for project in projects:
        project_comparison = generate_project_comparison(
            project,
            version_a_suffix,
            version_b_suffix,
            part2_dir,
            version_a_name,
            version_b_name,
        )
        lines.append(project_comparison)

    return "".join(lines)


def main():
    """Main execution function"""
    part2_dir = Path("/Users/wzr/TOSEM-2025/RESULTS/RQ2")
    output_dir = Path("/Users/wzr/TOSEM-2025/RESULTS/RQ3/agent_time_reports")

    output_dir.mkdir(parents=True, exist_ok=True)

    logger.info("Starting agent-level time comparison analysis...")

    # 1. MCP vs Hardcoded comparisons
    logger.info("Generating MCP vs Hardcoded comparisons...")
    mcp_hardcoded_projects = [
        "MarkdownValidator",
        "GameBuilder",
        "EmailResponder",
    ]

    comparison_content = generate_comparisons_for_projects(
        mcp_hardcoded_projects,
        "-MCP",
        "",
        part2_dir,
        "MCP",
        "Hardcoded",
        "MCP vs Hardcoded Agent-Level Comparison",
    )

    output_path = output_dir / "Agent_Time_Comparison_MCP_vs_Hardcoded.md"
    output_path.write_text(comparison_content, encoding="utf-8")
    logger.info(f"Created: {output_path}")

    # 2. MCP vs A2A comparisons
    logger.info("Generating MCP vs A2A comparisons...")
    version_projects = [
        "SQL_assistant",
        "intelligent_recruitment_platform",
        "landing_page_generator",
        "self_evaluation_loop_flow",
        "write_a_book_with_flows",
    ]

    comparison_content = generate_comparisons_for_projects(
        version_projects,
        "-MCP",
        "-A2A",
        part2_dir,
        "MCP",
        "A2A",
        "MCP vs A2A Agent-Level Comparison",
    )

    output_path = output_dir / "Agent_Time_Comparison_MCP_vs_A2A.md"
    output_path.write_text(comparison_content, encoding="utf-8")
    logger.info(f"Created: {output_path}")

    # 3. A2A vs A2A_mix comparisons
    logger.info("Generating A2A vs A2A_mix comparisons...")

    comparison_content = generate_comparisons_for_projects(
        version_projects,
        "-A2A",
        "-A2A_mix",
        part2_dir,
        "A2A",
        "A2A_mix",
        "A2A vs A2A_mix Agent-Level Comparison",
    )

    output_path = output_dir / "Agent_Time_Comparison_A2A_vs_A2A_mix.md"
    output_path.write_text(comparison_content, encoding="utf-8")
    logger.info(f"Created: {output_path}")

    logger.info("Agent-level time comparison analysis complete!")


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""
	Agent-Level Time Comparison Analysis Script

	This script analyzes agent time data from Part2 directories, comparing:
	- MCP vs Hardcoded
	- MCP vs A2A
	- A2A vs A2A_mix

	For each comparison, it shows:
	- Agent time proportions (percentage of total time)
	- Actual agent times (mean time per occurrence)
	- Differences in both absolute and percentage terms
	"""

	import csv
	import re
	from pathlib import Path
	from collections import defaultdict
	from typing import Dict, List, Tuple, Optional
	import logging

	# Setup logging
	logging.basicConfig(
	level=logging.INFO,
	format="%(asctime)s - %(levelname)s - %(message)s",
	)
	logger = logging.getLogger(__name__)


	def parse_agent_map(agent_map_path: Path) -> Dict[str, str]:
	"""
	Parse agent_map.md file to extract agent name mappings.

	Format example:
	--agent-map "Expert SQL Query Generator:SQL Query Generator"

	Returns:
	Dict mapping original name -> standardized name
	"""
	agent_map = {}

	if not agent_map_path.exists():
	logger.warning(f"Agent map not found: {agent_map_path}")
	return agent_map

	try:
	with open(agent_map_path, "r", encoding="utf-8") as f:
	content = f.read()

	# Pattern to match --agent-map "Original Name:Standardized Name"
	pattern = r'--agent-map\s+"([^:]+):([^"]+)"'
	matches = re.findall(pattern, content)

	for original, standardized in matches:
	agent_map[original.strip()] = standardized.strip()

	logger.info(f"Loaded {len(agent_map)} agent mappings from {agent_map_path}")
	except Exception as e:
	logger.error(f"Failed to parse agent map {agent_map_path}: {e}")

	return agent_map


	def load_agent_time_data(
	csv_path: Path, agent_map: Dict[str, str]
	) -> Dict[str, Dict[str, float]]:
	"""
	Load agent time data from agent_llm_tool_breakdown_by_model.csv.

	Returns:
	Dict[model][agent] = {
	'mean_time': mean time per occurrence in seconds,
	'total_time': total time in seconds,
	'occurrences': number of occurrences
	}
	"""
	agent_data = defaultdict(lambda: defaultdict(dict))

	if not csv_path.exists():
	logger.warning(f"CSV file not found: {csv_path}")
	return agent_data

	try:
	with open(csv_path, "r", encoding="utf-8") as f:
	reader = csv.DictReader(f)
	for row in reader:
	model = row["model"]
	agent_name = row["agent_name"]

	# Apply agent name mapping if available
	standardized_name = agent_map.get(agent_name, agent_name)

	occurrences = int(row["occurrences"])
	total_time_ms = float(row["total_agent_llm_tool_time_ms"])
	total_time_s = total_time_ms / 1000.0 # Convert to seconds

	mean_time = total_time_s / occurrences if occurrences > 0 else 0

	agent_data[model][standardized_name] = {
	"mean_time": mean_time,
	"total_time": total_time_s,
	"occurrences": occurrences,
	}

	logger.info(f"Loaded agent data from {csv_path}")
	except Exception as e:
	logger.error(f"Failed to load agent data from {csv_path}: {e}")

	return agent_data


	def calculate_agent_proportions(
	agent_data: Dict[str, Dict[str, float]],
	) -> Dict[str, Dict[str, float]]:
	"""
	Calculate what proportion of total time each agent takes per model.

	Returns:
	Dict[model][agent] = proportion (0-1)
	"""
	proportions = defaultdict(dict)

	for model, agents in agent_data.items():
	# Calculate total time across all agents for this model
	total_time = sum(data["total_time"] for data in agents.values())

	if total_time > 0:
	for agent, data in agents.items():
	proportions[model][agent] = data["total_time"] / total_time
	else:
	for agent in agents.keys():
	proportions[model][agent] = 0.0

	return proportions


	def generate_project_comparison(
	project_name: str,
	version_a_suffix: str,
	version_b_suffix: str,
	part2_dir: Path,
	version_a_name: str,
	version_b_name: str,
	) -> str:
	"""Generate agent-level comparison for a single project, organized by agent."""
	lines = []
	lines.append(f"# {project_name}: {version_a_name} vs {version_b_name}\n\n")

	# Get paths
	scenario_a = f"{project_name}{version_a_suffix}"
	scenario_b = f"{project_name}{version_b_suffix}"

	dir_a = part2_dir / scenario_a
	dir_b = part2_dir / scenario_b

	if not dir_a.exists() or not dir_b.exists():
	lines.append("_Data not available for comparison_\n\n")
	return "".join(lines)

	# Load agent maps
	map_a = parse_agent_map(dir_a / "agent_map.md")
	map_b = parse_agent_map(dir_b / "agent_map.md")

	# Load agent data
	data_a = load_agent_time_data(
	dir_a / "agent_llm_tool_breakdown_by_model.csv", map_a
	)
	data_b = load_agent_time_data(
	dir_b / "agent_llm_tool_breakdown_by_model.csv", map_b
	)

	if not data_a or not data_b:
	lines.append("_No agent data available_\n\n")
	return "".join(lines)

	# Calculate proportions
	prop_a = calculate_agent_proportions(data_a)
	prop_b = calculate_agent_proportions(data_b)

	# Get all models and agents
	all_models = sorted(set(data_a.keys()) \| set(data_b.keys()))

	# Get all unique agents across all models
	all_agents = set()
	for model in all_models:
	all_agents.update(data_a.get(model, {}).keys())
	all_agents.update(data_b.get(model, {}).keys())
	all_agents = sorted(all_agents)

	# Organize by agent
	for agent in all_agents:
	lines.append(f"## Agent: {agent}\n\n")

	# Per-model comparison for this agent
	lines.append(f"### Per-Model Comparison\n\n")
	lines.append(
	f"\| Model \| {version_a_name} Time (s) \| {version_b_name} Time (s) \| Time Diff \| "
	)
	lines.append(f"{version_a_name} % \| {version_b_name} % \| Proportion Diff \|\n")
	lines.append("\| --- \| --- \| --- \| --- \| --- \| --- \| --- \|\n")

	# Collect data for overall average
	overall_time_a = []
	overall_time_b = []
	overall_prop_a = []
	overall_prop_b = []

	for model in all_models:
	data_a_agent = data_a.get(model, {}).get(
	agent, {"mean_time": 0, "total_time": 0}
	)
	data_b_agent = data_b.get(model, {}).get(
	agent, {"mean_time": 0, "total_time": 0}
	)

	time_a = data_a_agent["mean_time"]
	time_b = data_b_agent["mean_time"]

	# Skip if both are 0 (agent not present in this model)
	if time_a == 0 and time_b == 0:
	continue

	prop_a_val = prop_a.get(model, {}).get(agent, 0) * 100
	prop_b_val = prop_b.get(model, {}).get(agent, 0) * 100

	time_diff = time_a - time_b
	time_pct = (time_diff / time_b * 100) if time_b > 0 else 0

	prop_diff = prop_a_val - prop_b_val

	lines.append(
	f"\| {model} \| {time_a:.2f} \| {time_b:.2f} \| "
	f"{time_diff:+.2f}s ({time_pct:+.1f}%) \| "
	f"{prop_a_val:.1f}% \| {prop_b_val:.1f}% \| "
	f"{prop_diff:+.1f}pp \|\n"
	)

	# Collect for average
	if time_a > 0:
	overall_time_a.append(time_a)
	overall_prop_a.append(prop_a_val)
	if time_b > 0:
	overall_time_b.append(time_b)
	overall_prop_b.append(prop_b_val)

	lines.append("\n")

	# Overall average for this agent across all models
	if overall_time_a or overall_time_b:
	lines.append(f"### Overall Average Across All Models\n\n")
	lines.append(
	f"\| Metric \| {version_a_name} \| {version_b_name} \| Difference \|\n"
	)
	lines.append("\| --- \| --- \| --- \| --- \|\n")

	avg_time_a = (
	sum(overall_time_a) / len(overall_time_a) if overall_time_a else 0
	)
	avg_time_b = (
	sum(overall_time_b) / len(overall_time_b) if overall_time_b else 0
	)
	avg_prop_a = (
	sum(overall_prop_a) / len(overall_prop_a) if overall_prop_a else 0
	)
	avg_prop_b = (
	sum(overall_prop_b) / len(overall_prop_b) if overall_prop_b else 0
	)

	time_diff_avg = avg_time_a - avg_time_b
	time_pct_avg = (time_diff_avg / avg_time_b * 100) if avg_time_b > 0 else 0
	prop_diff_avg = avg_prop_a - avg_prop_b

	lines.append(
	f"\| Mean Time (s) \| {avg_time_a:.2f} \| {avg_time_b:.2f} \| "
	f"{time_diff_avg:+.2f}s ({time_pct_avg:+.1f}%) \|\n"
	)
	lines.append(
	f"\| Time Proportion (%) \| {avg_prop_a:.1f}% \| {avg_prop_b:.1f}% \| "
	f"{prop_diff_avg:+.1f}pp \|\n"
	)
	lines.append("\n")

	lines.append("---\n\n")

	return "".join(lines)


	def generate_overall_comparison(
	projects: List[str],
	version_a_suffix: str,
	version_b_suffix: str,
	part2_dir: Path,
	version_a_name: str,
	version_b_name: str,
	comparison_title: str,
	) -> str:
	"""Generate overall agent-level comparison across multiple projects."""
	lines = []
	lines.append(f"# Overall {comparison_title}\n\n")
	lines.append(f"Averaged across all projects: {', '.join(projects)}\n\n")

	# Collect data from all projects
	overall_data_a = defaultdict(
	lambda: defaultdict(lambda: {"total_time": 0, "count": 0})
	)
	overall_data_b = defaultdict(
	lambda: defaultdict(lambda: {"total_time": 0, "count": 0})
	)

	for project in projects:
	scenario_a = f"{project}{version_a_suffix}"
	scenario_b = f"{project}{version_b_suffix}"

	dir_a = part2_dir / scenario_a
	dir_b = part2_dir / scenario_b

	if not dir_a.exists() or not dir_b.exists():
	continue

	# Load agent maps
	map_a = parse_agent_map(dir_a / "agent_map.md")
	map_b = parse_agent_map(dir_b / "agent_map.md")

	# Load agent data
	data_a = load_agent_time_data(
	dir_a / "agent_llm_tool_breakdown_by_model.csv", map_a
	)
	data_b = load_agent_time_data(
	dir_b / "agent_llm_tool_breakdown_by_model.csv", map_b
	)

	# Calculate proportions
	prop_a = calculate_agent_proportions(data_a)
	prop_b = calculate_agent_proportions(data_b)

	# Aggregate data
	for model, agents in data_a.items():
	for agent, agent_data in agents.items():
	overall_data_a[model][agent]["total_time"] += agent_data["total_time"]
	overall_data_a[model][agent]["count"] += agent_data["occurrences"]

	for model, agents in data_b.items():
	for agent, agent_data in agents.items():
	overall_data_b[model][agent]["total_time"] += agent_data["total_time"]
	overall_data_b[model][agent]["count"] += agent_data["occurrences"]

	# Calculate overall proportions and means
	all_models = sorted(set(overall_data_a.keys()) \| set(overall_data_b.keys()))

	for model in all_models:
	lines.append(f"## {model}\n\n")

	agents_a = set(overall_data_a[model].keys())
	agents_b = set(overall_data_b[model].keys())
	all_agents = sorted(agents_a \| agents_b)

	if not all_agents:
	lines.append("_No agent data for this model_\n\n")
	continue

	# Calculate total time for proportions
	total_time_a = sum(d["total_time"] for d in overall_data_a[model].values())
	total_time_b = sum(d["total_time"] for d in overall_data_b[model].values())

	# Table header
	lines.append(
	f"\| Agent \| {version_a_name} Mean (s) \| {version_b_name} Mean (s) \| Time Diff \| "
	)
	lines.append(f"{version_a_name} % \| {version_b_name} % \| Proportion Diff \|\n")
	lines.append("\| --- \| --- \| --- \| --- \| --- \| --- \| --- \|\n")

	for agent in all_agents:
	data_a = overall_data_a[model][agent]
	data_b = overall_data_b[model][agent]

	mean_a = (
	data_a["total_time"] / data_a["count"] if data_a["count"] > 0 else 0
	)
	mean_b = (
	data_b["total_time"] / data_b["count"] if data_b["count"] > 0 else 0
	)

	prop_a = (
	(data_a["total_time"] / total_time_a * 100) if total_time_a > 0 else 0
	)
	prop_b = (
	(data_b["total_time"] / total_time_b * 100) if total_time_b > 0 else 0
	)

	time_diff = mean_a - mean_b
	time_pct = (time_diff / mean_b * 100) if mean_b > 0 else 0

	prop_diff = prop_a - prop_b

	lines.append(
	f"\| {agent} \| {mean_a:.2f} \| {mean_b:.2f} \| "
	f"{time_diff:+.2f}s ({time_pct:+.1f}%) \| "
	f"{prop_a:.1f}% \| {prop_b:.1f}% \| "
	f"{prop_diff:+.1f}pp \|\n"
	)
	return "".join(lines)


	def generate_overall_summary(
	projects: List[str],
	version_a_suffix: str,
	version_b_suffix: str,
	part2_dir: Path,
	version_a_name: str,
	version_b_name: str,
	) -> str:
	"""Generate overall summary across all projects and models."""
	lines = []
	lines.append("## Overall Summary (All Projects, All Models)\n\n")

	# Collect data from all projects
	overall_data_a = defaultdict(lambda: {"total_time": 0, "count": 0})
	overall_data_b = defaultdict(lambda: {"total_time": 0, "count": 0})

	for project in projects:
	scenario_a = f"{project}{version_a_suffix}"
	scenario_b = f"{project}{version_b_suffix}"

	dir_a = part2_dir / scenario_a
	dir_b = part2_dir / scenario_b

	if not dir_a.exists() or not dir_b.exists():
	continue

	# Load agent maps
	map_a = parse_agent_map(dir_a / "agent_map.md")
	map_b = parse_agent_map(dir_b / "agent_map.md")

	# Load agent data
	data_a = load_agent_time_data(
	dir_a / "agent_llm_tool_breakdown_by_model.csv", map_a
	)
	data_b = load_agent_time_data(
	dir_b / "agent_llm_tool_breakdown_by_model.csv", map_b
	)

	# Aggregate data across all models
	for model, agents in data_a.items():
	for agent, agent_data in agents.items():
	overall_data_a[agent]["total_time"] += agent_data["total_time"]
	overall_data_a[agent]["count"] += agent_data["occurrences"]

	for model, agents in data_b.items():
	for agent, agent_data in agents.items():
	overall_data_b[agent]["total_time"] += agent_data["total_time"]
	overall_data_b[agent]["count"] += agent_data["occurrences"]

	# Get all agents
	all_agents = sorted(set(overall_data_a.keys()) \| set(overall_data_b.keys()))

	if not all_agents:
	lines.append("_No data available_\n\n")
	return "".join(lines)

	# Calculate total time for proportions
	total_time_a = sum(d["total_time"] for d in overall_data_a.values())
	total_time_b = sum(d["total_time"] for d in overall_data_b.values())

	# Table header
	lines.append(
	f"\| Agent \| {version_a_name} Mean (s) \| {version_b_name} Mean (s) \| Time Diff \| "
	)
	lines.append(f"{version_a_name} % \| {version_b_name} % \| Proportion Diff \|\n")
	lines.append("\| --- \| --- \| --- \| --- \| --- \| --- \| --- \|\n")

	for agent in all_agents:
	data_a = overall_data_a[agent]
	data_b = overall_data_b[agent]

	mean_a = data_a["total_time"] / data_a["count"] if data_a["count"] > 0 else 0
	mean_b = data_b["total_time"] / data_b["count"] if data_b["count"] > 0 else 0

	prop_a = (data_a["total_time"] / total_time_a * 100) if total_time_a > 0 else 0
	prop_b = (data_b["total_time"] / total_time_b * 100) if total_time_b > 0 else 0

	time_diff = mean_a - mean_b
	time_pct = (time_diff / mean_b * 100) if mean_b > 0 else 0

	prop_diff = prop_a - prop_b

	lines.append(
	f"\| {agent} \| {mean_a:.2f} \| {mean_b:.2f} \| "
	f"{time_diff:+.2f}s ({time_pct:+.1f}%) \| "
	f"{prop_a:.1f}% \| {prop_b:.1f}% \| "
	f"{prop_diff:+.1f}pp \|\n"
	)

	lines.append("\n---\n\n")
	return "".join(lines)


	def generate_comparisons_for_projects(
	projects: List[str],
	version_a_suffix: str,
	version_b_suffix: str,
	part2_dir: Path,
	version_a_name: str,
	version_b_name: str,
	comparison_title: str,
	) -> str:
	"""Generate project-by-project agent-level comparisons."""
	lines = []
	lines.append(f"# {comparison_title}\n\n")
	lines.append(f"Projects included: {', '.join(projects)}\n\n")
	lines.append("---\n\n")

	# Add overall summary first
	overall_summary = generate_overall_summary(
	projects,
	version_a_suffix,
	version_b_suffix,
	part2_dir,
	version_a_name,
	version_b_name,
	)
	lines.append(overall_summary)

	# Generate comparison for each project
	for project in projects:
	project_comparison = generate_project_comparison(
	project,
	version_a_suffix,
	version_b_suffix,
	part2_dir,
	version_a_name,
	version_b_name,
	)
	lines.append(project_comparison)

	return "".join(lines)


	def main():
	"""Main execution function"""
	part2_dir = Path("/Users/wzr/TOSEM-2025/RESULTS/RQ2")
	output_dir = Path("/Users/wzr/TOSEM-2025/RESULTS/RQ3/agent_time_reports")

	output_dir.mkdir(parents=True, exist_ok=True)

	logger.info("Starting agent-level time comparison analysis...")

	# 1. MCP vs Hardcoded comparisons
	logger.info("Generating MCP vs Hardcoded comparisons...")
	mcp_hardcoded_projects = [
	"MarkdownValidator",
	"GameBuilder",
	"EmailResponder",
	]

	comparison_content = generate_comparisons_for_projects(
	mcp_hardcoded_projects,
	"-MCP",
	"",
	part2_dir,
	"MCP",
	"Hardcoded",
	"MCP vs Hardcoded Agent-Level Comparison",
	)

	output_path = output_dir / "Agent_Time_Comparison_MCP_vs_Hardcoded.md"
	output_path.write_text(comparison_content, encoding="utf-8")
	logger.info(f"Created: {output_path}")

	# 2. MCP vs A2A comparisons
	logger.info("Generating MCP vs A2A comparisons...")
	version_projects = [
	"SQL_assistant",
	"intelligent_recruitment_platform",
	"landing_page_generator",
	"self_evaluation_loop_flow",
	"write_a_book_with_flows",
	]

	comparison_content = generate_comparisons_for_projects(
	version_projects,
	"-MCP",
	"-A2A",
	part2_dir,
	"MCP",
	"A2A",
	"MCP vs A2A Agent-Level Comparison",
	)

	output_path = output_dir / "Agent_Time_Comparison_MCP_vs_A2A.md"
	output_path.write_text(comparison_content, encoding="utf-8")
	logger.info(f"Created: {output_path}")

	# 3. A2A vs A2A_mix comparisons
	logger.info("Generating A2A vs A2A_mix comparisons...")

	comparison_content = generate_comparisons_for_projects(
	version_projects,
	"-A2A",
	"-A2A_mix",
	part2_dir,
	"A2A",
	"A2A_mix",
	"A2A vs A2A_mix Agent-Level Comparison",
	)

	output_path = output_dir / "Agent_Time_Comparison_A2A_vs_A2A_mix.md"
	output_path.write_text(comparison_content, encoding="utf-8")
	logger.info(f"Created: {output_path}")

	logger.info("Agent-level time comparison analysis complete!")


	if __name__ == "__main__":
	main()