Upload app.py

app.py

@@ -6,7 +6,7 @@ from pathlib import Path
 import pandas as pd
 import os
 import json
-from utils.viz import create_scatter_plot, create_flow_chart, create_bar_chart, create_task_success_heatmap
+from utils.viz import create_scatter_plot, create_flow_chart, create_bar_chart, create_task_success_heatmap, create_leaderboard
 from utils.processing import check_and_process_uploads
 from huggingface_hub import snapshot_download
 from apscheduler.schedulers.background import BackgroundScheduler
@@ -48,8 +48,8 @@ def get_analyzed_traces(agent_name, benchmark_name):
 def get_failure_report(agent_name, benchmark_name):
     return preprocessor.get_failure_report(agent_name, benchmark_name)
 
-def parse_json_files(folder_path, benchmark_name):
-    return preprocessor.get_parsed_results(benchmark_name)
+def parse_json_files(folder_path, benchmark_name, aggregate=True):
+    return preprocessor.get_parsed_results(benchmark_name, aggregate=aggregate)
 
 def update_agent_dropdown(benchmark_name, metric):
     df = parse_json_files(os.path.join(abs_path, "evals_live"), benchmark_name)
@@ -463,7 +463,7 @@ with gr.Blocks(theme=my_theme, css='css.css') as demo:
             with gr.Row():
                 with gr.Column(scale=2):
                     Leaderboard(
-                        value=parse_json_files(os.path.join(abs_path, "evals_live"), 'usaco'),
+                        value=create_leaderboard(parse_json_files(os.path.join(abs_path, "evals_live"), 'usaco'), ci_metrics=["Accuracy", "Total Cost"]),
                         select_columns=SelectColumns(
                             default_selection=config.USACO_ON_LOAD_COLUMNS + ["Verified"],
                             cant_deselect=["Agent Name"],
@@ -472,15 +472,15 @@ with gr.Blocks(theme=my_theme, css='css.css') as demo:
                         hide_columns=config.USACO_HIDE_COLUMNS,
                         search_columns=config.USACO_SEARCH_COLUMNS,
                     )
+                    gr.Markdown("""*95% CIs calculated using Student's t-distribution.*""", elem_classes=["text-right"])
             with gr.Row():
                 gr.Markdown("### Accuracy vs. Cost for USACO agents")
             with gr.Row():
-                scatter_plot = gr.Plot(create_scatter_plot(parse_json_files(os.path.join(abs_path, "evals_live"), 'usaco'), "Total Cost", "Accuracy", "Total Cost (in USD)", "Accuracy", ["Agent Name"]))
+                scatter_plot = gr.Plot(create_scatter_plot(parse_json_files(os.path.join(abs_path, "evals_live"), 'usaco', aggregate=False), "Total Cost", "Accuracy", "Total Cost (in USD)", "Accuracy", ["Agent Name"]))
             
-            gr.Markdown("")
-            gr.Markdown("")
+            gr.HTML('<div style="height: 30px;"></div>')
             gr.Markdown("## Task success heatmap")
-            gr.Markdown("The task success heatmap shows which agent can solve which tasks. Agents are sorted by total accuracy (higher is better); tasks in USACO are sorted by decreasing order of difficulty (tasks on the left are solved by the most agents; tasks on the right are solved by the least")
+            gr.Markdown("The task success heatmap shows which agent can solve which tasks. Agents are sorted by total accuracy (higher is better); tasks in USACO are sorted by decreasing order of difficulty (tasks on the left are solved by the most agents; tasks on the right are solved by the least. For agents that have been run more than once, the run with the highest score is shown.")
             with gr.Row():
                 task_success_heatmap = gr.Plot()
             demo.load(
@@ -624,400 +624,907 @@ with gr.Blocks(theme=my_theme, css='css.css') as demo:
                                         inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown], 
                                         outputs=[raw_call_details])
         
-        
-        with gr.Tab("SWE-Bench Verified"):
+        with gr.Tab("SWE-bench Verified"):
             gr.Markdown("""SWE-bench is a dataset that tests systems' ability to solve GitHub issues automatically. Verified is a human-validated subset of 500 problems reviewed by software engineers. The  We are currently actively developing this platform and this benchmark is not fully implemented yet.""")
             with gr.Row():
                 with gr.Column(scale=2):
                     Leaderboard(
-                        value=parse_json_files(os.path.join(abs_path, "evals_live"), 'swebench_verified'),
+                        value=create_leaderboard(parse_json_files(os.path.join(abs_path, "evals_live"), 'swebench_verified'), ci_metrics=["Accuracy", "Total Cost"]),
                         select_columns=SelectColumns(
                             default_selection=config.SWEBENCH_ON_LOAD_COLUMNS + ["Verified"],
                             cant_deselect=["Agent Name"],
                             label="Select Columns to Display:",
                         ),
                         hide_columns=config.SWEBENCH_HIDE_COLUMNS,
-                        search_columns=config.SWEBENCH_SEARCH_COLUMNS
+                        search_columns=config.SWEBENCH_SEARCH_COLUMNS,
                     )
+                    gr.Markdown("""*95% CIs calculated using Student's t-distribution.*""", elem_classes=["text-right"])
             with gr.Row():
-                scatter_plot = gr.Plot(create_scatter_plot(parse_json_files(os.path.join(abs_path, "evals_live"), 'swebench_verified'), "Total Cost", "Accuracy", "Total Cost (in USD)", "Accuracy", ["Agent Name"]))
+                gr.Markdown("### Accuracy vs. Cost for SWE-bench agents")
+            with gr.Row():
+                scatter_plot = gr.Plot(create_scatter_plot(parse_json_files(os.path.join(abs_path, "evals_live"), 'swebench_verified', aggregate=False), "Total Cost", "Accuracy", "Total Cost (in USD)", "Accuracy", ["Agent Name"]))
             
-            gr.Markdown("")
-            gr.Markdown("")
+            gr.HTML('<div style="height: 30px;"></div>')
             gr.Markdown("## Task success heatmap")
+            gr.Markdown("The task success heatmap shows which agent can solve which tasks. Agents are sorted by total accuracy (higher is better); tasks in SWE-bench are sorted by decreasing order of difficulty (tasks on the left are solved by the most agents; tasks on the right are solved by the least. For agents that have been run more than once, the run with the highest score is shown.")
             with gr.Row():
                 task_success_heatmap = gr.Plot()
             demo.load(
             lambda: create_task_success_heatmap(
                 preprocessor.get_task_success_data('swebench_verified'),
-                'SWEBench Verified'
+                'SWE-bench Verified'
             ),
             outputs=[task_success_heatmap]
             )
-            
-            gr.Markdown("")
-            gr.Markdown("")
-            gr.Markdown("## Failure report for each agent")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    failure_report_agent_dropdown = gr.Dropdown(label="Select Agent for Failure Report")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    failure_categories_overview = gr.Markdown()
-            
-                with gr.Column(scale=1):
-                    failure_categories_chart = gr.Plot()
 
-            # Initialize the failure report agent dropdown with all agents
-            demo.load(update_agent_dropdown, 
-                    inputs=[gr.Textbox(value="swebench_verified", visible=False), gr.Textbox(value="Accuracy", visible=False)], 
-                    outputs=[failure_report_agent_dropdown])
-            
-            # Update failure report when agent is selected
-            failure_report_agent_dropdown.change(update_failure_report,
-                                                inputs=[failure_report_agent_dropdown, gr.Textbox(value="swebench_verified", visible=False)],
-                                                outputs=[failure_categories_overview, failure_categories_chart])
-            
-            gr.Markdown("")
-            gr.Markdown("")
-            gr.Markdown("## Agent monitor")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    agent_dropdown = gr.Dropdown(label="Select Agent")
-                with gr.Column(scale=1):
-                    task_dropdown = gr.Dropdown(label="Select SWE-Bench Task")
-            with gr.Row():
-                task_overview = gr.Markdown()
-            with gr.Row():
-                flow_chart = gr.Plot(label="Task Flow")
-
-            # Initialize the agent dropdown with the best agent
-            demo.load(update_agent_dropdown, inputs=[gr.Textbox(value="swebench_verified", visible=False), gr.Textbox(value="Accuracy", visible=False)], outputs=[agent_dropdown])
-            demo.load(update_task_analysis, inputs=[gr.Textbox(value="swebench_verified", visible=False), agent_dropdown], outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
-
-            agent_dropdown.change(update_task_analysis, 
-                                  inputs=[gr.Textbox(value="swebench_verified", visible=False), agent_dropdown],
-                                  outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
-            task_dropdown.change(update_task_details,
-                                 inputs=[gr.Textbox(value="swebench_verified", visible=False), agent_dropdown, task_dropdown],
-                                 outputs=[task_overview, flow_chart, gr.Textbox(visible=False)])
+            gr.HTML("""
+            <style>
+                .grouped-section {
+                    border: 2px solid #dee2e6; /* Color matching unactivated tabs */
+                    border-radius: 10px;
+                    padding: 30px;
+                    margin-top: 40px;
+                    margin-bottom: 40px;
+                    position: relative;
+                }
+
+                .grouped-section-title {
+                    font-size: 1.7em;
+                    font-weight: bold;
+                    color: #2c3e50;
+                    margin-bottom: 20px;
+                    padding-bottom: 10px;
+                    border-bottom: 2px solid #dee2e6;
+                }
+            </style>
+            """)
+            with gr.Group(elem_classes=["grouped-section"]):
+                gr.Markdown("# Agent monitor", elem_classes=["grouped-section-title"], elem_id="agent-monitor")
+
+                gr.HTML('<div style="height: 10px;"></div>')
+                gr.Markdown("## Failure report for each agent")
+                gr.Markdown('Select an agent to see why the agent fails to solve tasks correctly. Note that these descriptions (and the failure categories) are generated by LLM-based evaluations of the agent logs and may contain inaccuracies.')
+                gr.HTML('<div style="height: 10px;"></div>')
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        failure_report_agent_dropdown = gr.Dropdown(label="Select Agent for Failure Report")
+                gr.HTML('<div style="height: 10px;"></div>')
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        failure_categories_overview = gr.Markdown()
+                
+                    with gr.Column(scale=1):
+                        failure_categories_chart = gr.Plot()
+
+                # Initialize the failure report agent dropdown with all agents
+                demo.load(update_agent_dropdown, 
+                        inputs=[gr.Textbox(value="swebench_verified", visible=False), gr.Textbox(value="Accuracy", visible=False)], 
+                        outputs=[failure_report_agent_dropdown])
+                
+                # Update failure report when agent is selected
+                failure_report_agent_dropdown.change(update_failure_report,
+                                                    inputs=[failure_report_agent_dropdown, gr.Textbox(value="swebench_verified", visible=False)],
+                                                    outputs=[failure_categories_overview, failure_categories_chart])
+
+                gr.HTML('<div style="height: 30px;"></div>')
+                gr.Markdown("## Task overview")
+                gr.HTML('<div style="height: 10px;"></div>')
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        agent_dropdown = gr.Dropdown(label="Select Agent")
+                    with gr.Column(scale=1):
+                        task_dropdown = gr.Dropdown(label="Select SWE-bench Verified Task")
+                gr.HTML('<div style="height: 10px;"></div>')
+                with gr.Row():
+                    task_overview = gr.Markdown()
+                with gr.Row():
+                    flow_chart = gr.Plot(label="Task Flow")
+
+                # Initialize the agent dropdown with the best agent
+                demo.load(update_agent_dropdown, inputs=[gr.Textbox(value="swebench_verified", visible=False), gr.Textbox(value="Accuracy", visible=False)], outputs=[agent_dropdown])
+                demo.load(update_task_analysis, inputs=[gr.Textbox(value="swebench_verified", visible=False), agent_dropdown], outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+
+                agent_dropdown.change(update_task_analysis, 
+                                    inputs=[gr.Textbox(value="swebench_verified", visible=False), agent_dropdown],
+                                    outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+                task_dropdown.change(update_task_details,
+                                    inputs=[gr.Textbox(value="swebench_verified", visible=False), agent_dropdown, task_dropdown],
+                                    outputs=[task_overview, flow_chart, gr.Textbox(visible=False)])
             
             gr.Markdown("## Raw predictions")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    raw_agent_dropdown = gr.Dropdown(label="Select Agent")
-                with gr.Column(scale=1):
-                    raw_task_dropdown = gr.Dropdown(label="Select Task")
-                with gr.Column(scale=1):
-                    raw_step_dropdown = gr.Dropdown(label="Select Step")
-            
-            with gr.Row():
-                raw_call_details = gr.HTML()
-            
-            def update_raw_task_dropdown(agent_name):
-                analyzed_traces = get_analyzed_traces(agent_name, "swebench_verified")
-                if not analyzed_traces:
-                    return gr.Dropdown(choices=[], label="Select Task"), gr.Dropdown(choices=[], label="Select Step"), f"No raw predictions data available for agent: {agent_name}."
-                task_ids = list(analyzed_traces.keys())
-                steps = analyzed_traces[task_ids[0]]['steps']
-                return gr.Dropdown(choices=task_ids, label="Select Task", value=task_ids[0]), gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), update_raw_call_details(agent_name, task_ids[0], 0)
-
-            def update_raw_step_dropdown(agent_name, task_id):
-                analyzed_traces = get_analyzed_traces(agent_name, "swebench_verified")
-                if not analyzed_traces or task_id not in analyzed_traces:
-                    return gr.Dropdown(choices=[], label="Select Step", value="No data available.")
-                steps = analyzed_traces[task_id]['steps']
-                return gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), format_call_info(steps[0], 0)
-
-            def update_raw_call_details(agent_name, task_id, step_index):
-                analyzed_traces = get_analyzed_traces(agent_name, "swebench_verified")
-                if not analyzed_traces or task_id not in analyzed_traces:
-                    return "No data available for this selection."
-                steps = analyzed_traces[task_id]['steps']
-                if step_index is None:
-                    return "Invalid step selection."
-                step = steps[step_index]
-                return format_call_info(step, step_index)
-
-            # Initialize the raw agent dropdown with all agents
-            demo.load(update_agent_dropdown, 
-                    inputs=[gr.Textbox(value="swebench_verified", visible=False), gr.Textbox(value="Accuracy", visible=False)], 
-                    outputs=[raw_agent_dropdown])
-            demo.load(update_raw_task_dropdown,
-                    inputs=[raw_agent_dropdown],
-                    outputs=[raw_task_dropdown, raw_step_dropdown])
-            demo.load(update_raw_call_details,
-                    inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown],
-                    outputs=[raw_call_details])
-
-            raw_agent_dropdown.change(update_raw_task_dropdown, 
-                                    inputs=[raw_agent_dropdown], 
-                                    outputs=[raw_task_dropdown, raw_step_dropdown, raw_call_details])
-            raw_task_dropdown.change(update_raw_step_dropdown, 
-                                    inputs=[raw_agent_dropdown, raw_task_dropdown], 
-                                    outputs=[raw_step_dropdown, raw_call_details])
-            raw_step_dropdown.change(update_raw_call_details, 
-                                    inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown], 
-                                    outputs=[raw_call_details])
-            
-        with gr.Tab("SWE-Bench Lite"):
+            gr.Markdown('Select an agent to see the raw predictions made by the agent for each task. We also provide information on token usage for each call.')
+            with gr.Accordion("Expand to inspect raw predictions of agents...", open=False):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        raw_agent_dropdown = gr.Dropdown(label="Select Agent")
+                    with gr.Column(scale=1):
+                        raw_task_dropdown = gr.Dropdown(label="Select Task")
+                    with gr.Column(scale=1):
+                        raw_step_dropdown = gr.Dropdown(label="Select Step")
+                with gr.Row():
+                    raw_call_details = gr.HTML()
+                
+                def update_raw_task_dropdown(agent_name):
+                    analyzed_traces = get_analyzed_traces(agent_name, "swebench_verified")
+                    if not analyzed_traces:
+                        return gr.Dropdown(choices=[], label="Select Task"), gr.Dropdown(choices=[], label="Select Step"), f"No raw predictions data available for agent: {agent_name}."
+                    task_ids = list(analyzed_traces.keys())
+                    steps = analyzed_traces[task_ids[0]]['steps']
+                    return gr.Dropdown(choices=task_ids, label="Select Task", value=task_ids[0]), gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), format_call_info(get_analyzed_traces(agent_name, "swebench_verified")[task_ids[0]]['steps'][0], 0)
+
+                def update_raw_step_dropdown(agent_name, task_id):
+                    analyzed_traces = get_analyzed_traces(agent_name, "swebench_verified")
+                    if not analyzed_traces or task_id not in analyzed_traces:
+                        return gr.Dropdown(choices=[], label="Select Step", value="No data available.")
+                    steps = analyzed_traces[task_id]['steps']
+                    return gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), format_call_info(steps[0], 0)
+
+                def update_raw_call_details(agent_name, task_id, step_index):
+                    analyzed_traces = get_analyzed_traces(agent_name, "swebench_verified")
+                    if not analyzed_traces or task_id not in analyzed_traces:
+                        return "No data available for this selection."
+                    steps = analyzed_traces[task_id]['steps']
+                    if step_index is None:
+                        return "Invalid step selection."
+                    step = steps[step_index]
+                    return format_call_info(step, step_index)
+
+                # Initialize the raw agent dropdown with all agents
+                demo.load(update_agent_dropdown, 
+                        inputs=[gr.Textbox(value="swebench_verified", visible=False), gr.Textbox(value="Accuracy", visible=False)], 
+                        outputs=[raw_agent_dropdown])
+                demo.load(update_raw_task_dropdown,
+                        inputs=[raw_agent_dropdown],
+                        outputs=[raw_task_dropdown, raw_step_dropdown])
+                demo.load(update_raw_call_details,
+                        inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown],
+                        outputs=[raw_call_details])
+
+                raw_agent_dropdown.change(update_raw_task_dropdown, 
+                                        inputs=[raw_agent_dropdown], 
+                                        outputs=[raw_task_dropdown, raw_step_dropdown, raw_call_details])
+                raw_task_dropdown.change(update_raw_step_dropdown, 
+                                        inputs=[raw_agent_dropdown, raw_task_dropdown], 
+                                        outputs=[raw_step_dropdown, raw_call_details])
+                raw_step_dropdown.change(update_raw_call_details, 
+                                        inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown], 
+                                        outputs=[raw_call_details])
+        
+        
+        with gr.Tab("SWE-bench Lite"):
             gr.Markdown("""SWE-bench is a dataset that tests systems' ability to solve GitHub issues automatically. Lite is a subset of 300 tasks of the original SWE-bench. We are currently actively developing this platform and this benchmark is not fully implemented yet.""")
             with gr.Row():
                 with gr.Column(scale=2):
                     Leaderboard(
-                        value=parse_json_files(os.path.join(abs_path, "evals_live"), 'swebench_lite'),
+                        value=create_leaderboard(parse_json_files(os.path.join(abs_path, "evals_live"), 'swebench_lite'), ci_metrics=["Accuracy", "Total Cost"]),
                         select_columns=SelectColumns(
                             default_selection=config.SWEBENCH_ON_LOAD_COLUMNS + ["Verified"],
                             cant_deselect=["Agent Name"],
                             label="Select Columns to Display:",
                         ),
+                        hide_columns=config.SWEBENCH_HIDE_COLUMNS,
                         search_columns=config.SWEBENCH_SEARCH_COLUMNS,
-                        hide_columns=config.SWEBENCH_HIDE_COLUMNS
                     )
+                    gr.Markdown("""*95% CIs calculated using Student's t-distribution.*""", elem_classes=["text-right"])
             with gr.Row():
-                scatter_plot = gr.Plot(create_scatter_plot(parse_json_files(os.path.join(abs_path, "evals_live"), 'swebench_lite'), "Total Cost", "Accuracy", "Total Cost (in USD)", "Accuracy", ["Agent Name"]))
-
-            gr.Markdown("")
-            gr.Markdown("")
+                gr.Markdown("### Accuracy vs. Cost for SWE-bench agents")
+            with gr.Row():
+                scatter_plot = gr.Plot(create_scatter_plot(parse_json_files(os.path.join(abs_path, "evals_live"), 'swebench_lite', aggregate=False), "Total Cost", "Accuracy", "Total Cost (in USD)", "Accuracy", ["Agent Name"]))
+            
+            gr.HTML('<div style="height: 30px;"></div>')
             gr.Markdown("## Task success heatmap")
+            gr.Markdown("The task success heatmap shows which agent can solve which tasks. Agents are sorted by total accuracy (higher is better); tasks in SWE-bench are sorted by decreasing order of difficulty (tasks on the left are solved by the most agents; tasks on the right are solved by the least. For agents that have been run more than once, the run with the highest score is shown.")
             with gr.Row():
                 task_success_heatmap = gr.Plot()
             demo.load(
             lambda: create_task_success_heatmap(
                 preprocessor.get_task_success_data('swebench_lite'),
-                'SWEBench Lite'
+                'SWE-bench Lite'
             ),
             outputs=[task_success_heatmap]
             )
-            
-            gr.Markdown("")
-            gr.Markdown("")
-            gr.Markdown("## Failure report for each agent")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    failure_report_agent_dropdown = gr.Dropdown(label="Select Agent for Failure Report")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    failure_categories_overview = gr.Markdown()
-            
-                with gr.Column(scale=1):
-                    failure_categories_chart = gr.Plot()
 
-            # Initialize the failure report agent dropdown with all agents
-            demo.load(update_agent_dropdown, 
-                    inputs=[gr.Textbox(value="swebench_lite", visible=False), gr.Textbox(value="Accuracy", visible=False)], 
-                    outputs=[failure_report_agent_dropdown])
-            
-            # Update failure report when agent is selected
-            failure_report_agent_dropdown.change(update_failure_report,
-                                                inputs=[failure_report_agent_dropdown, gr.Textbox(value="swebench_lite", visible=False)],
-                                                outputs=[failure_categories_overview, failure_categories_chart])
-            
-            gr.Markdown("")
-            gr.Markdown("")
-            gr.Markdown("## Agent monitor")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    agent_dropdown = gr.Dropdown(label="Select Agent")
-                with gr.Column(scale=1):
-                    task_dropdown = gr.Dropdown(label="Select SWE-Bench Task")
-            with gr.Row():
-                task_overview = gr.Markdown()
-            with gr.Row():
-                flow_chart = gr.Plot(label="Task Flow")
+            gr.HTML("""
+            <style>
+                .grouped-section {
+                    border: 2px solid #dee2e6; /* Color matching unactivated tabs */
+                    border-radius: 10px;
+                    padding: 30px;
+                    margin-top: 40px;
+                    margin-bottom: 40px;
+                    position: relative;
+                }
 
-            # Initialize the agent dropdown with the best agent
-            demo.load(update_agent_dropdown, inputs=[gr.Textbox(value="swebench_lite", visible=False), gr.Textbox(value="Accuracy", visible=False)], outputs=[agent_dropdown])
-            demo.load(update_task_analysis, inputs=[gr.Textbox(value="swebench_lite", visible=False), agent_dropdown], outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+                .grouped-section-title {
+                    font-size: 1.7em;
+                    font-weight: bold;
+                    color: #2c3e50;
+                    margin-bottom: 20px;
+                    padding-bottom: 10px;
+                    border-bottom: 2px solid #dee2e6;
+                }
+            </style>
+            """)
+            with gr.Group(elem_classes=["grouped-section"]):
+                gr.Markdown("# Agent monitor", elem_classes=["grouped-section-title"], elem_id="agent-monitor")
 
-            agent_dropdown.change(update_task_analysis, 
-                                  inputs=[gr.Textbox(value="swebench_lite", visible=False), agent_dropdown],
-                                  outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
-            task_dropdown.change(update_task_details,
-                                 inputs=[gr.Textbox(value="swebench_lite", visible=False), agent_dropdown, task_dropdown],
-                                 outputs=[task_overview, flow_chart, gr.Textbox(visible=False)])
+                gr.HTML('<div style="height: 10px;"></div>')
+                gr.Markdown("## Failure report for each agent")
+                gr.Markdown('Select an agent to see why the agent fails to solve tasks correctly. Note that these descriptions (and the failure categories) are generated by LLM-based evaluations of the agent logs and may contain inaccuracies.')
+                gr.HTML('<div style="height: 10px;"></div>')
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        failure_report_agent_dropdown = gr.Dropdown(label="Select Agent for Failure Report")
+                gr.HTML('<div style="height: 10px;"></div>')
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        failure_categories_overview = gr.Markdown()
+                
+                    with gr.Column(scale=1):
+                        failure_categories_chart = gr.Plot()
 
-           
-            gr.Markdown("## Raw predictions")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    raw_agent_dropdown = gr.Dropdown(label="Select Agent")
-                with gr.Column(scale=1):
-                    raw_task_dropdown = gr.Dropdown(label="Select Task")
-                with gr.Column(scale=1):
-                    raw_step_dropdown = gr.Dropdown(label="Select Step")
-            
-            with gr.Row():
-                raw_call_details = gr.HTML()
-            
-            def update_raw_task_dropdown(agent_name):
-                analyzed_traces = get_analyzed_traces(agent_name, "swebench_lite")
-                if not analyzed_traces:
-                    return gr.Dropdown(choices=[], label="Select Task"), gr.Dropdown(choices=[], label="Select Step"), f"No raw predictions data available for agent: {agent_name}."
-                task_ids = list(analyzed_traces.keys())
-                steps = analyzed_traces[task_ids[0]]['steps']
-                return gr.Dropdown(choices=task_ids, label="Select Task", value=task_ids[0]), gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), update_raw_call_details(agent_name, task_ids[0], 0)
-
-            def update_raw_step_dropdown(agent_name, task_id):
-                analyzed_traces = get_analyzed_traces(agent_name, "swebench_lite")
-                if not analyzed_traces or task_id not in analyzed_traces:
-                    return gr.Dropdown(choices=[], label="Select Step", value="No data available.")
-                steps = analyzed_traces[task_id]['steps']
-                return gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), format_call_info(steps[0], 0)
-
-            def update_raw_call_details(agent_name, task_id, step_index):
-                analyzed_traces = get_analyzed_traces(agent_name, "swebench_lite")
-                if not analyzed_traces or task_id not in analyzed_traces:
-                    return "No data available for this selection."
-                steps = analyzed_traces[task_id]['steps']
-                if step_index is None:
-                    return "Invalid step selection."
-                step = steps[step_index]
-                return format_call_info(step, step_index)
-
-            # Initialize the raw agent dropdown with all agents
-            demo.load(update_agent_dropdown, 
-                    inputs=[gr.Textbox(value="swebench_lite", visible=False), gr.Textbox(value="Accuracy", visible=False)], 
-                    outputs=[raw_agent_dropdown])
-            demo.load(update_raw_task_dropdown,
-                    inputs=[raw_agent_dropdown],
-                    outputs=[raw_task_dropdown, raw_step_dropdown])
-            demo.load(update_raw_call_details,
-                    inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown],
-                    outputs=[raw_call_details])
-
-            raw_agent_dropdown.change(update_raw_task_dropdown, 
-                                    inputs=[raw_agent_dropdown], 
-                                    outputs=[raw_task_dropdown, raw_step_dropdown, raw_call_details])
-            raw_task_dropdown.change(update_raw_step_dropdown, 
-                                    inputs=[raw_agent_dropdown, raw_task_dropdown], 
-                                    outputs=[raw_step_dropdown, raw_call_details])
-            raw_step_dropdown.change(update_raw_call_details, 
-                                    inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown], 
-                                    outputs=[raw_call_details])
+                # Initialize the failure report agent dropdown with all agents
+                demo.load(update_agent_dropdown, 
+                        inputs=[gr.Textbox(value="swebench_lite", visible=False), gr.Textbox(value="Accuracy", visible=False)], 
+                        outputs=[failure_report_agent_dropdown])
+                
+                # Update failure report when agent is selected
+                failure_report_agent_dropdown.change(update_failure_report,
+                                                    inputs=[failure_report_agent_dropdown, gr.Textbox(value="swebench_lite", visible=False)],
+                                                    outputs=[failure_categories_overview, failure_categories_chart])
+
+                gr.HTML('<div style="height: 30px;"></div>')
+                gr.Markdown("## Task overview")
+                gr.HTML('<div style="height: 10px;"></div>')
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        agent_dropdown = gr.Dropdown(label="Select Agent")
+                    with gr.Column(scale=1):
+                        task_dropdown = gr.Dropdown(label="Select SWE-bench Lite Task")
+                gr.HTML('<div style="height: 10px;"></div>')
+                with gr.Row():
+                    task_overview = gr.Markdown()
+                with gr.Row():
+                    flow_chart = gr.Plot(label="Task Flow")
+
+                # Initialize the agent dropdown with the best agent
+                demo.load(update_agent_dropdown, inputs=[gr.Textbox(value="swebench_lite", visible=False), gr.Textbox(value="Accuracy", visible=False)], outputs=[agent_dropdown])
+                demo.load(update_task_analysis, inputs=[gr.Textbox(value="swebench_lite", visible=False), agent_dropdown], outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+
+                agent_dropdown.change(update_task_analysis, 
+                                    inputs=[gr.Textbox(value="swebench_lite", visible=False), agent_dropdown],
+                                    outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+                task_dropdown.change(update_task_details,
+                                    inputs=[gr.Textbox(value="swebench_lite", visible=False), agent_dropdown, task_dropdown],
+                                    outputs=[task_overview, flow_chart, gr.Textbox(visible=False)])
             
+            gr.Markdown("## Raw predictions")
+            gr.Markdown('Select an agent to see the raw predictions made by the agent for each task. We also provide information on token usage for each call.')
+            with gr.Accordion("Expand to inspect raw predictions of agents...", open=False):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        raw_agent_dropdown = gr.Dropdown(label="Select Agent")
+                    with gr.Column(scale=1):
+                        raw_task_dropdown = gr.Dropdown(label="Select Task")
+                    with gr.Column(scale=1):
+                        raw_step_dropdown = gr.Dropdown(label="Select Step")
+                with gr.Row():
+                    raw_call_details = gr.HTML()
+                
+                def update_raw_task_dropdown(agent_name):
+                    analyzed_traces = get_analyzed_traces(agent_name, "swebench_lite")
+                    if not analyzed_traces:
+                        return gr.Dropdown(choices=[], label="Select Task"), gr.Dropdown(choices=[], label="Select Step"), f"No raw predictions data available for agent: {agent_name}."
+                    task_ids = list(analyzed_traces.keys())
+                    steps = analyzed_traces[task_ids[0]]['steps']
+                    return gr.Dropdown(choices=task_ids, label="Select Task", value=task_ids[0]), gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), format_call_info(get_analyzed_traces(agent_name, "swebench_lite")[task_ids[0]]['steps'][0], 0)
+
+                def update_raw_step_dropdown(agent_name, task_id):
+                    analyzed_traces = get_analyzed_traces(agent_name, "swebench_lite")
+                    if not analyzed_traces or task_id not in analyzed_traces:
+                        return gr.Dropdown(choices=[], label="Select Step", value="No data available.")
+                    steps = analyzed_traces[task_id]['steps']
+                    return gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), format_call_info(steps[0], 0)
+
+                def update_raw_call_details(agent_name, task_id, step_index):
+                    analyzed_traces = get_analyzed_traces(agent_name, "swebench_lite")
+                    if not analyzed_traces or task_id not in analyzed_traces:
+                        return "No data available for this selection."
+                    steps = analyzed_traces[task_id]['steps']
+                    if step_index is None:
+                        return "Invalid step selection."
+                    step = steps[step_index]
+                    return format_call_info(step, step_index)
+
+                # Initialize the raw agent dropdown with all agents
+                demo.load(update_agent_dropdown, 
+                        inputs=[gr.Textbox(value="swebench_lite", visible=False), gr.Textbox(value="Accuracy", visible=False)], 
+                        outputs=[raw_agent_dropdown])
+                demo.load(update_raw_task_dropdown,
+                        inputs=[raw_agent_dropdown],
+                        outputs=[raw_task_dropdown, raw_step_dropdown])
+                demo.load(update_raw_call_details,
+                        inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown],
+                        outputs=[raw_call_details])
+
+                raw_agent_dropdown.change(update_raw_task_dropdown, 
+                                        inputs=[raw_agent_dropdown], 
+                                        outputs=[raw_task_dropdown, raw_step_dropdown, raw_call_details])
+                raw_task_dropdown.change(update_raw_step_dropdown, 
+                                        inputs=[raw_agent_dropdown, raw_task_dropdown], 
+                                        outputs=[raw_step_dropdown, raw_call_details])
+                raw_step_dropdown.change(update_raw_call_details, 
+                                        inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown], 
+                                        outputs=[raw_call_details])
+        
+        
+        
         with gr.Tab("MLAgentBench"):
             gr.Markdown("""MLAgentBench is a suite of end-to-end Machine Learning (ML) experimentation tasks, where the agent aims to take a given dataset and a machine learning task description and autonomously develop or improve an ML model. We are currently actively developing this platform and this benchmark is not fully implemented yet. In particular, we only include one agent and a subset of tasks for this benchmark.""")
             with gr.Row():
                 with gr.Column(scale=2):
                     Leaderboard(
-                        value=parse_json_files(os.path.join(abs_path, "evals_live"), 'mlagentbench'),
+                        value=create_leaderboard(parse_json_files(os.path.join(abs_path, "evals_live"), 'mlagentbench')),
                         select_columns=SelectColumns(
                             default_selection=config.MLAGENTBENCH_ON_LOAD_COLUMNS + ["Verified"],
                             cant_deselect=["Agent Name"],
                             label="Select Columns to Display:",
                         ),
-                        search_columns=config.MLAGENTBENCH_SEARCH_COLUMNS,
                         hide_columns=config.MLAGENTBENCH_HIDE_COLUMNS,
+                        search_columns=config.MLAGENTBENCH_SEARCH_COLUMNS,
                     )
+                    gr.Markdown("""*95% CIs calculated using Student's t-distribution.*""", elem_classes=["text-right"])
             with gr.Row():
-                scatter_plot = gr.Plot(create_scatter_plot(parse_json_files(os.path.join(abs_path, "evals_live"), 'mlagentbench'), "Total Cost", "Overall Score", "Total Cost (in USD)", "Overall Score", ["Agent Name"]))
-
-            gr.Markdown("")
-            gr.Markdown("")
-            gr.Markdown("## Failure report for each agent")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    failure_report_agent_dropdown = gr.Dropdown(label="Select Agent for Failure Report")
+                gr.Markdown("### Accuracy vs. Cost for MLAgentBench agents")
             with gr.Row():
-                with gr.Column(scale=1):
-                    failure_categories_overview = gr.Markdown()
+                scatter_plot = gr.Plot(create_scatter_plot(parse_json_files(os.path.join(abs_path, "evals_live"), 'mlagentbench', aggregate=False), "Total Cost", "Overall Score", "Total Cost (in USD)", "Overall Score", ["Agent Name"]))
             
-                with gr.Column(scale=1):
-                    failure_categories_chart = gr.Plot()
+            # gr.HTML('<div style="height: 30px;"></div>')
+            # gr.Markdown("## Task success heatmap")
+            # gr.Markdown("The task success heatmap shows which agent can solve which tasks. Agents are sorted by total accuracy (higher is better); tasks in USACO are sorted by decreasing order of difficulty (tasks on the left are solved by the most agents; tasks on the right are solved by the least. For agents that have been run more than once, the run with the highest score is shown.")
+            # with gr.Row():
+            #     task_success_heatmap = gr.Plot()
+            # demo.load(
+            # lambda: create_task_success_heatmap(
+            #     preprocessor.get_task_success_data('usaco'),
+            #     'USACO'
+            # ),
+            # outputs=[task_success_heatmap]
+            # )
 
-            # Initialize the failure report agent dropdown with all agents
-            demo.load(update_agent_dropdown, 
-                    inputs=[gr.Textbox(value="mlagentbench", visible=False), gr.Textbox(value="Overall Score", visible=False)], 
-                    outputs=[failure_report_agent_dropdown])
+            gr.HTML("""
+            <style>
+                .grouped-section {
+                    border: 2px solid #dee2e6; /* Color matching unactivated tabs */
+                    border-radius: 10px;
+                    padding: 30px;
+                    margin-top: 40px;
+                    margin-bottom: 40px;
+                    position: relative;
+                }
+
+                .grouped-section-title {
+                    font-size: 1.7em;
+                    font-weight: bold;
+                    color: #2c3e50;
+                    margin-bottom: 20px;
+                    padding-bottom: 10px;
+                    border-bottom: 2px solid #dee2e6;
+                }
+            </style>
+            """)
+            with gr.Group(elem_classes=["grouped-section"]):
+                gr.Markdown("# Agent monitor", elem_classes=["grouped-section-title"], elem_id="agent-monitor")
+
+                # gr.HTML('<div style="height: 10px;"></div>')
+                # gr.Markdown("## Failure report for each agent")
+                # gr.Markdown('Select an agent to see why the agent fails to solve tasks correctly. Note that these descriptions (and the failure categories) are generated by LLM-based evaluations of the agent logs and may contain inaccuracies.')
+                # gr.HTML('<div style="height: 10px;"></div>')
+                # with gr.Row():
+                #     with gr.Column(scale=1):
+                #         failure_report_agent_dropdown = gr.Dropdown(label="Select Agent for Failure Report")
+                # gr.HTML('<div style="height: 10px;"></div>')
+                # with gr.Row():
+                #     with gr.Column(scale=1):
+                #         failure_categories_overview = gr.Markdown()
+                
+                #     with gr.Column(scale=1):
+                #         failure_categories_chart = gr.Plot()
+
+                # # Initialize the failure report agent dropdown with all agents
+                # demo.load(update_agent_dropdown, 
+                #         inputs=[gr.Textbox(value="mlagentbench", visible=False), gr.Textbox(value="Overall Score", visible=False)], 
+                #         outputs=[failure_report_agent_dropdown])
+                
+                # # Update failure report when agent is selected
+                # failure_report_agent_dropdown.change(update_failure_report,
+                #                                     inputs=[failure_report_agent_dropdown, gr.Textbox(value="mlagentbench", visible=False)],
+                #                                     outputs=[failure_categories_overview, failure_categories_chart])
+
+                gr.HTML('<div style="height: 30px;"></div>')
+                gr.Markdown("## Task overview")
+                gr.HTML('<div style="height: 10px;"></div>')
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        agent_dropdown = gr.Dropdown(label="Select Agent")
+                    with gr.Column(scale=1):
+                        task_dropdown = gr.Dropdown(label="Select MLAgentBench Task")
+                gr.HTML('<div style="height: 10px;"></div>')
+                with gr.Row():
+                    task_overview = gr.Markdown()
+                with gr.Row():
+                    flow_chart = gr.Plot(label="Task Flow")
+
+                # Initialize the agent dropdown with the best agent
+                demo.load(update_agent_dropdown, inputs=[gr.Textbox(value="mlagentbench", visible=False), gr.Textbox(value="Overall Score", visible=False)], outputs=[agent_dropdown])
+                demo.load(update_task_analysis, inputs=[gr.Textbox(value="mlagentbench", visible=False), agent_dropdown], outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+
+                agent_dropdown.change(update_task_analysis, 
+                                    inputs=[gr.Textbox(value="mlagentbench", visible=False), agent_dropdown],
+                                    outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+                task_dropdown.change(update_task_details,
+                                    inputs=[gr.Textbox(value="mlagentbench", visible=False), agent_dropdown, task_dropdown],
+                                    outputs=[task_overview, flow_chart, gr.Textbox(visible=False)])
+            
+            gr.Markdown("## Raw predictions")
+            gr.Markdown('Select an agent to see the raw predictions made by the agent for each task. We also provide information on token usage for each call.')
+            with gr.Accordion("Expand to inspect raw predictions of agents...", open=False):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        raw_agent_dropdown = gr.Dropdown(label="Select Agent")
+                    with gr.Column(scale=1):
+                        raw_task_dropdown = gr.Dropdown(label="Select Task")
+                    with gr.Column(scale=1):
+                        raw_step_dropdown = gr.Dropdown(label="Select Step")
+                with gr.Row():
+                    raw_call_details = gr.HTML()
+                
+                def update_raw_task_dropdown(agent_name):
+                    analyzed_traces = get_analyzed_traces(agent_name, "mlagentbench")
+                    if not analyzed_traces:
+                        return gr.Dropdown(choices=[], label="Select Task"), gr.Dropdown(choices=[], label="Select Step"), f"No raw predictions data available for agent: {agent_name}."
+                    task_ids = list(analyzed_traces.keys())
+                    steps = analyzed_traces[task_ids[0]]['steps']
+                    return gr.Dropdown(choices=task_ids, label="Select Task", value=task_ids[0]), gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), format_call_info(get_analyzed_traces(agent_name, "mlagentbench")[task_ids[0]]['steps'][0], 0)
+
+                def update_raw_step_dropdown(agent_name, task_id):
+                    analyzed_traces = get_analyzed_traces(agent_name, "mlagentbench")
+                    if not analyzed_traces or task_id not in analyzed_traces:
+                        return gr.Dropdown(choices=[], label="Select Step", value="No data available.")
+                    steps = analyzed_traces[task_id]['steps']
+                    return gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), format_call_info(steps[0], 0)
+
+                def update_raw_call_details(agent_name, task_id, step_index):
+                    analyzed_traces = get_analyzed_traces(agent_name, "mlagentbench")
+                    if not analyzed_traces or task_id not in analyzed_traces:
+                        return "No data available for this selection."
+                    steps = analyzed_traces[task_id]['steps']
+                    if step_index is None:
+                        return "Invalid step selection."
+                    step = steps[step_index]
+                    return format_call_info(step, step_index)
+
+                # Initialize the raw agent dropdown with all agents
+                demo.load(update_agent_dropdown, 
+                        inputs=[gr.Textbox(value="mlagentbench", visible=False), gr.Textbox(value="Overall Score", visible=False)], 
+                        outputs=[raw_agent_dropdown])
+                demo.load(update_raw_task_dropdown,
+                        inputs=[raw_agent_dropdown],
+                        outputs=[raw_task_dropdown, raw_step_dropdown])
+                demo.load(update_raw_call_details,
+                        inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown],
+                        outputs=[raw_call_details])
+
+                raw_agent_dropdown.change(update_raw_task_dropdown, 
+                                        inputs=[raw_agent_dropdown], 
+                                        outputs=[raw_task_dropdown, raw_step_dropdown, raw_call_details])
+                raw_task_dropdown.change(update_raw_step_dropdown, 
+                                        inputs=[raw_agent_dropdown, raw_task_dropdown], 
+                                        outputs=[raw_step_dropdown, raw_call_details])
+                raw_step_dropdown.change(update_raw_call_details, 
+                                        inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown], 
+                                        outputs=[raw_call_details])
+        
+        
+        # with gr.Tab("SWE-Bench Verified"):
+        #     gr.Markdown("""SWE-bench is a dataset that tests systems' ability to solve GitHub issues automatically. Verified is a human-validated subset of 500 problems reviewed by software engineers. The  We are currently actively developing this platform and this benchmark is not fully implemented yet.""")
+        #     with gr.Row():
+        #         with gr.Column(scale=2):
+        #             Leaderboard(
+        #                 value=parse_json_files(os.path.join(abs_path, "evals_live"), 'swebench_verified'),
+        #                 select_columns=SelectColumns(
+        #                     default_selection=config.SWEBENCH_ON_LOAD_COLUMNS + ["Verified"],
+        #                     cant_deselect=["Agent Name"],
+        #                     label="Select Columns to Display:",
+        #                 ),
+        #                 hide_columns=config.SWEBENCH_HIDE_COLUMNS,
+        #                 search_columns=config.SWEBENCH_SEARCH_COLUMNS
+        #             )
+        #             gr.Markdown("""*95% CIs calculated using Student's t-distribution.*""", elem_classes=["text-right"])
+        #     with gr.Row():
+        #         scatter_plot = gr.Plot(create_scatter_plot(parse_json_files(os.path.join(abs_path, "evals_live"), 'swebench_verified', aggregate=False), "Total Cost", "Accuracy", "Total Cost (in USD)", "Accuracy", ["Agent Name"]))
             
-            # Update failure report when agent is selected
-            failure_report_agent_dropdown.change(update_failure_report,
-                                                inputs=[failure_report_agent_dropdown, gr.Textbox(value="mlagentbench", visible=False)],
-                                                outputs=[failure_categories_overview, failure_categories_chart])
+        #     gr.Markdown("")
+        #     gr.Markdown("")
+        #     gr.Markdown("## Task success heatmap")
+        #     with gr.Row():
+        #         task_success_heatmap = gr.Plot()
+        #     demo.load(
+        #     lambda: create_task_success_heatmap(
+        #         preprocessor.get_task_success_data('swebench_verified'),
+        #         'SWEBench Verified'
+        #     ),
+        #     outputs=[task_success_heatmap]
+        #     )
             
-            gr.Markdown("")
-            gr.Markdown("")
-            gr.Markdown("## Agent monitor")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    agent_dropdown = gr.Dropdown(label="Select Agent")
-                with gr.Column(scale=1):
-                    task_dropdown = gr.Dropdown(label="Select SWE-Bench Task")
-            with gr.Row():
-                task_overview = gr.Markdown()
-            with gr.Row():
-                flow_chart = gr.Plot(label="Task Flow")
+        #     gr.Markdown("")
+        #     gr.Markdown("")
+        #     gr.Markdown("## Failure report for each agent")
+        #     with gr.Row():
+        #         with gr.Column(scale=1):
+        #             failure_report_agent_dropdown = gr.Dropdown(label="Select Agent for Failure Report")
+        #     with gr.Row():
+        #         with gr.Column(scale=1):
+        #             failure_categories_overview = gr.Markdown()
+            
+        #         with gr.Column(scale=1):
+        #             failure_categories_chart = gr.Plot()
 
-            # Initialize the agent dropdown with the best agent
-            demo.load(update_agent_dropdown, inputs=[gr.Textbox(value="mlagentbench", visible=False), gr.Textbox(value="Overall Score", visible=False)], outputs=[agent_dropdown])
-            demo.load(update_task_analysis, inputs=[gr.Textbox(value="mlagentbench", visible=False), agent_dropdown], outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+        #     # Initialize the failure report agent dropdown with all agents
+        #     demo.load(update_agent_dropdown, 
+        #             inputs=[gr.Textbox(value="swebench_verified", visible=False), gr.Textbox(value="Accuracy", visible=False)], 
+        #             outputs=[failure_report_agent_dropdown])
+            
+        #     # Update failure report when agent is selected
+        #     failure_report_agent_dropdown.change(update_failure_report,
+        #                                         inputs=[failure_report_agent_dropdown, gr.Textbox(value="swebench_verified", visible=False)],
+        #                                         outputs=[failure_categories_overview, failure_categories_chart])
+            
+        #     gr.Markdown("")
+        #     gr.Markdown("")
+        #     gr.Markdown("## Agent monitor")
+        #     with gr.Row():
+        #         with gr.Column(scale=1):
+        #             agent_dropdown = gr.Dropdown(label="Select Agent")
+        #         with gr.Column(scale=1):
+        #             task_dropdown = gr.Dropdown(label="Select SWE-Bench Task")
+        #     with gr.Row():
+        #         task_overview = gr.Markdown()
+        #     with gr.Row():
+        #         flow_chart = gr.Plot(label="Task Flow")
+
+        #     # Initialize the agent dropdown with the best agent
+        #     demo.load(update_agent_dropdown, inputs=[gr.Textbox(value="swebench_verified", visible=False), gr.Textbox(value="Accuracy", visible=False)], outputs=[agent_dropdown])
+        #     demo.load(update_task_analysis, inputs=[gr.Textbox(value="swebench_verified", visible=False), agent_dropdown], outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+
+        #     agent_dropdown.change(update_task_analysis, 
+        #                           inputs=[gr.Textbox(value="swebench_verified", visible=False), agent_dropdown],
+        #                           outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+        #     task_dropdown.change(update_task_details,
+        #                          inputs=[gr.Textbox(value="swebench_verified", visible=False), agent_dropdown, task_dropdown],
+        #                          outputs=[task_overview, flow_chart, gr.Textbox(visible=False)])
+            
+        #     gr.Markdown("## Raw predictions")
+        #     with gr.Row():
+        #         with gr.Column(scale=1):
+        #             raw_agent_dropdown = gr.Dropdown(label="Select Agent")
+        #         with gr.Column(scale=1):
+        #             raw_task_dropdown = gr.Dropdown(label="Select Task")
+        #         with gr.Column(scale=1):
+        #             raw_step_dropdown = gr.Dropdown(label="Select Step")
+            
+        #     with gr.Row():
+        #         raw_call_details = gr.HTML()
+            
+        #     def update_raw_task_dropdown(agent_name):
+        #         analyzed_traces = get_analyzed_traces(agent_name, "swebench_verified")
+        #         if not analyzed_traces:
+        #             return gr.Dropdown(choices=[], label="Select Task"), gr.Dropdown(choices=[], label="Select Step"), f"No raw predictions data available for agent: {agent_name}."
+        #         task_ids = list(analyzed_traces.keys())
+        #         steps = analyzed_traces[task_ids[0]]['steps']
+        #         return gr.Dropdown(choices=task_ids, label="Select Task", value=task_ids[0]), gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), update_raw_call_details(agent_name, task_ids[0], 0)
+
+        #     def update_raw_step_dropdown(agent_name, task_id):
+        #         analyzed_traces = get_analyzed_traces(agent_name, "swebench_verified")
+        #         if not analyzed_traces or task_id not in analyzed_traces:
+        #             return gr.Dropdown(choices=[], label="Select Step", value="No data available.")
+        #         steps = analyzed_traces[task_id]['steps']
+        #         return gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), format_call_info(steps[0], 0)
+
+        #     def update_raw_call_details(agent_name, task_id, step_index):
+        #         analyzed_traces = get_analyzed_traces(agent_name, "swebench_verified")
+        #         if not analyzed_traces or task_id not in analyzed_traces:
+        #             return "No data available for this selection."
+        #         steps = analyzed_traces[task_id]['steps']
+        #         if step_index is None:
+        #             return "Invalid step selection."
+        #         step = steps[step_index]
+        #         return format_call_info(step, step_index)
+
+        #     # Initialize the raw agent dropdown with all agents
+        #     demo.load(update_agent_dropdown, 
+        #             inputs=[gr.Textbox(value="swebench_verified", visible=False), gr.Textbox(value="Accuracy", visible=False)], 
+        #             outputs=[raw_agent_dropdown])
+        #     demo.load(update_raw_task_dropdown,
+        #             inputs=[raw_agent_dropdown],
+        #             outputs=[raw_task_dropdown, raw_step_dropdown])
+        #     demo.load(update_raw_call_details,
+        #             inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown],
+        #             outputs=[raw_call_details])
+
+        #     raw_agent_dropdown.change(update_raw_task_dropdown, 
+        #                             inputs=[raw_agent_dropdown], 
+        #                             outputs=[raw_task_dropdown, raw_step_dropdown, raw_call_details])
+        #     raw_task_dropdown.change(update_raw_step_dropdown, 
+        #                             inputs=[raw_agent_dropdown, raw_task_dropdown], 
+        #                             outputs=[raw_step_dropdown, raw_call_details])
+        #     raw_step_dropdown.change(update_raw_call_details, 
+        #                             inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown], 
+        #                             outputs=[raw_call_details])
+            
+        # with gr.Tab("SWE-Bench Lite"):
+        #     gr.Markdown("""SWE-bench is a dataset that tests systems' ability to solve GitHub issues automatically. Lite is a subset of 300 tasks of the original SWE-bench. We are currently actively developing this platform and this benchmark is not fully implemented yet.""")
+        #     with gr.Row():
+        #         with gr.Column(scale=2):
+        #             Leaderboard(
+        #                 value=create_leaderboard(parse_json_files(os.path.join(abs_path, "evals_live"), 'swebench_lite'), ci_metrics=['Accuracy', 'Total Cost']),
+        #                 select_columns=SelectColumns(
+        #                     default_selection=config.SWEBENCH_ON_LOAD_COLUMNS + ["Verified"],
+        #                     cant_deselect=["Agent Name"],
+        #                     label="Select Columns to Display:",
+        #                 ),
+        #                 search_columns=config.SWEBENCH_SEARCH_COLUMNS,
+        #                 hide_columns=config.SWEBENCH_HIDE_COLUMNS
+        #             )
+        #             # make right aligned markdown
+        #             gr.Markdown("""*95% CIs calculated using Student's t-distribution.*""", elem_classes=["text-right"])
+        #     with gr.Row():
+        #         scatter_plot = gr.Plot(create_scatter_plot(parse_json_files(os.path.join(abs_path, "evals_live"), 'swebench_lite', aggregate=True), "Total Cost", "Accuracy", "Total Cost (in USD)", "Accuracy", ["Agent Name"]))
+
+        #     gr.Markdown("")
+        #     gr.Markdown("")
+        #     gr.Markdown("## Task success heatmap")
+        #     with gr.Row():
+        #         task_success_heatmap = gr.Plot()
+        #     demo.load(
+        #     lambda: create_task_success_heatmap(
+        #         preprocessor.get_task_success_data('swebench_lite'),
+        #         'SWEBench Lite'
+        #     ),
+        #     outputs=[task_success_heatmap]
+        #     )
+            
+        #     gr.Markdown("")
+        #     gr.Markdown("")
+        #     gr.Markdown("## Failure report for each agent")
+        #     with gr.Row():
+        #         with gr.Column(scale=1):
+        #             failure_report_agent_dropdown = gr.Dropdown(label="Select Agent for Failure Report")
+        #     with gr.Row():
+        #         with gr.Column(scale=1):
+        #             failure_categories_overview = gr.Markdown()
+            
+        #         with gr.Column(scale=1):
+        #             failure_categories_chart = gr.Plot()
 
-            agent_dropdown.change(update_task_analysis, 
-                                  inputs=[gr.Textbox(value="mlagentbench", visible=False), agent_dropdown],
-                                  outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
-            task_dropdown.change(update_task_details,
-                                 inputs=[gr.Textbox(value="mlagentbench", visible=False), agent_dropdown, task_dropdown],
-                                 outputs=[task_overview, flow_chart, gr.Textbox(visible=False)])
+        #     # Initialize the failure report agent dropdown with all agents
+        #     demo.load(update_agent_dropdown, 
+        #             inputs=[gr.Textbox(value="swebench_lite", visible=False), gr.Textbox(value="Accuracy", visible=False)], 
+        #             outputs=[failure_report_agent_dropdown])
+            
+        #     # Update failure report when agent is selected
+        #     failure_report_agent_dropdown.change(update_failure_report,
+        #                                         inputs=[failure_report_agent_dropdown, gr.Textbox(value="swebench_lite", visible=False)],
+        #                                         outputs=[failure_categories_overview, failure_categories_chart])
+            
+        #     gr.Markdown("")
+        #     gr.Markdown("")
+        #     gr.Markdown("## Agent monitor")
+        #     with gr.Row():
+        #         with gr.Column(scale=1):
+        #             agent_dropdown = gr.Dropdown(label="Select Agent")
+        #         with gr.Column(scale=1):
+        #             task_dropdown = gr.Dropdown(label="Select SWE-Bench Task")
+        #     with gr.Row():
+        #         task_overview = gr.Markdown()
+        #     with gr.Row():
+        #         flow_chart = gr.Plot(label="Task Flow")
+
+        #     # Initialize the agent dropdown with the best agent
+        #     demo.load(update_agent_dropdown, inputs=[gr.Textbox(value="swebench_lite", visible=False), gr.Textbox(value="Accuracy", visible=False)], outputs=[agent_dropdown])
+        #     demo.load(update_task_analysis, inputs=[gr.Textbox(value="swebench_lite", visible=False), agent_dropdown], outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+
+        #     agent_dropdown.change(update_task_analysis, 
+        #                           inputs=[gr.Textbox(value="swebench_lite", visible=False), agent_dropdown],
+        #                           outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+        #     task_dropdown.change(update_task_details,
+        #                          inputs=[gr.Textbox(value="swebench_lite", visible=False), agent_dropdown, task_dropdown],
+        #                          outputs=[task_overview, flow_chart, gr.Textbox(visible=False)])
 
+           
+        #     gr.Markdown("## Raw predictions")
+        #     with gr.Row():
+        #         with gr.Column(scale=1):
+        #             raw_agent_dropdown = gr.Dropdown(label="Select Agent")
+        #         with gr.Column(scale=1):
+        #             raw_task_dropdown = gr.Dropdown(label="Select Task")
+        #         with gr.Column(scale=1):
+        #             raw_step_dropdown = gr.Dropdown(label="Select Step")
+            
+        #     with gr.Row():
+        #         raw_call_details = gr.HTML()
+            
+        #     def update_raw_task_dropdown(agent_name):
+        #         analyzed_traces = get_analyzed_traces(agent_name, "swebench_lite")
+        #         if not analyzed_traces:
+        #             return gr.Dropdown(choices=[], label="Select Task"), gr.Dropdown(choices=[], label="Select Step"), f"No raw predictions data available for agent: {agent_name}."
+        #         task_ids = list(analyzed_traces.keys())
+        #         steps = analyzed_traces[task_ids[0]]['steps']
+        #         return gr.Dropdown(choices=task_ids, label="Select Task", value=task_ids[0]), gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), update_raw_call_details(agent_name, task_ids[0], 0)
+
+        #     def update_raw_step_dropdown(agent_name, task_id):
+        #         analyzed_traces = get_analyzed_traces(agent_name, "swebench_lite")
+        #         if not analyzed_traces or task_id not in analyzed_traces:
+        #             return gr.Dropdown(choices=[], label="Select Step", value="No data available.")
+        #         steps = analyzed_traces[task_id]['steps']
+        #         return gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), format_call_info(steps[0], 0)
+
+        #     def update_raw_call_details(agent_name, task_id, step_index):
+        #         analyzed_traces = get_analyzed_traces(agent_name, "swebench_lite")
+        #         if not analyzed_traces or task_id not in analyzed_traces:
+        #             return "No data available for this selection."
+        #         steps = analyzed_traces[task_id]['steps']
+        #         if step_index is None:
+        #             return "Invalid step selection."
+        #         step = steps[step_index]
+        #         return format_call_info(step, step_index)
+
+        #     # Initialize the raw agent dropdown with all agents
+        #     demo.load(update_agent_dropdown, 
+        #             inputs=[gr.Textbox(value="swebench_lite", visible=False), gr.Textbox(value="Accuracy", visible=False)], 
+        #             outputs=[raw_agent_dropdown])
+        #     demo.load(update_raw_task_dropdown,
+        #             inputs=[raw_agent_dropdown],
+        #             outputs=[raw_task_dropdown, raw_step_dropdown])
+        #     demo.load(update_raw_call_details,
+        #             inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown],
+        #             outputs=[raw_call_details])
+
+        #     raw_agent_dropdown.change(update_raw_task_dropdown, 
+        #                             inputs=[raw_agent_dropdown], 
+        #                             outputs=[raw_task_dropdown, raw_step_dropdown, raw_call_details])
+        #     raw_task_dropdown.change(update_raw_step_dropdown, 
+        #                             inputs=[raw_agent_dropdown, raw_task_dropdown], 
+        #                             outputs=[raw_step_dropdown, raw_call_details])
+        #     raw_step_dropdown.change(update_raw_call_details, 
+        #                             inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown], 
+        #                             outputs=[raw_call_details])
+            
         
-            gr.Markdown("## Raw predictions")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    raw_agent_dropdown = gr.Dropdown(label="Select Agent")
-                with gr.Column(scale=1):
-                    raw_task_dropdown = gr.Dropdown(label="Select Task")
-                with gr.Column(scale=1):
-                    raw_step_dropdown = gr.Dropdown(label="Select Step")
+        
+        # with gr.Tab("MLAgentBench"):
+        #     gr.Markdown("""MLAgentBench is a suite of end-to-end Machine Learning (ML) experimentation tasks, where the agent aims to take a given dataset and a machine learning task description and autonomously develop or improve an ML model. We are currently actively developing this platform and this benchmark is not fully implemented yet. In particular, we only include one agent and a subset of tasks for this benchmark.""")
+        #     with gr.Row():
+        #         with gr.Column(scale=2):
+        #             Leaderboard(
+        #                 value=parse_json_files(os.path.join(abs_path, "evals_live"), 'mlagentbench'),
+        #                 select_columns=SelectColumns(
+        #                     default_selection=config.MLAGENTBENCH_ON_LOAD_COLUMNS + ["Verified"],
+        #                     cant_deselect=["Agent Name"],
+        #                     label="Select Columns to Display:",
+        #                 ),
+        #                 search_columns=config.MLAGENTBENCH_SEARCH_COLUMNS,
+        #                 hide_columns=config.MLAGENTBENCH_HIDE_COLUMNS,
+        #             )
+        #             gr.Markdown("""*95% CIs calculated using Student's t-distribution.*""", elem_classes=["text-right"])
+        #     with gr.Row():
+        #         scatter_plot = gr.Plot(create_scatter_plot(parse_json_files(os.path.join(abs_path, "evals_live"), 'mlagentbench', aggregate=False), "Total Cost", "Overall Score", "Total Cost (in USD)", "Overall Score", ["Agent Name"]))
+
+        #     gr.Markdown("")
+        #     gr.Markdown("")
+        #     gr.Markdown("## Failure report for each agent")
+        #     with gr.Row():
+        #         with gr.Column(scale=1):
+        #             failure_report_agent_dropdown = gr.Dropdown(label="Select Agent for Failure Report")
+        #     with gr.Row():
+        #         with gr.Column(scale=1):
+        #             failure_categories_overview = gr.Markdown()
             
-            with gr.Row():
-                raw_call_details = gr.HTML()
+        #         with gr.Column(scale=1):
+        #             failure_categories_chart = gr.Plot()
+
+        #     # Initialize the failure report agent dropdown with all agents
+        #     demo.load(update_agent_dropdown, 
+        #             inputs=[gr.Textbox(value="mlagentbench", visible=False), gr.Textbox(value="Overall Score", visible=False)], 
+        #             outputs=[failure_report_agent_dropdown])
+            
+        #     # Update failure report when agent is selected
+        #     failure_report_agent_dropdown.change(update_failure_report,
+        #                                         inputs=[failure_report_agent_dropdown, gr.Textbox(value="mlagentbench", visible=False)],
+        #                                         outputs=[failure_categories_overview, failure_categories_chart])
+            
+        #     gr.Markdown("")
+        #     gr.Markdown("")
+        #     gr.Markdown("## Agent monitor")
+        #     with gr.Row():
+        #         with gr.Column(scale=1):
+        #             agent_dropdown = gr.Dropdown(label="Select Agent")
+        #         with gr.Column(scale=1):
+        #             task_dropdown = gr.Dropdown(label="Select SWE-Bench Task")
+        #     with gr.Row():
+        #         task_overview = gr.Markdown()
+        #     with gr.Row():
+        #         flow_chart = gr.Plot(label="Task Flow")
+
+        #     # Initialize the agent dropdown with the best agent
+        #     demo.load(update_agent_dropdown, inputs=[gr.Textbox(value="mlagentbench", visible=False), gr.Textbox(value="Overall Score", visible=False)], outputs=[agent_dropdown])
+        #     demo.load(update_task_analysis, inputs=[gr.Textbox(value="mlagentbench", visible=False), agent_dropdown], outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+
+        #     agent_dropdown.change(update_task_analysis, 
+        #                           inputs=[gr.Textbox(value="mlagentbench", visible=False), agent_dropdown],
+        #                           outputs=[task_overview, flow_chart, task_dropdown, gr.Textbox(visible=False)])
+        #     task_dropdown.change(update_task_details,
+        #                          inputs=[gr.Textbox(value="mlagentbench", visible=False), agent_dropdown, task_dropdown],
+        #                          outputs=[task_overview, flow_chart, gr.Textbox(visible=False)])
+
+        
+        #     gr.Markdown("## Raw predictions")
+        #     with gr.Row():
+        #         with gr.Column(scale=1):
+        #             raw_agent_dropdown = gr.Dropdown(label="Select Agent")
+        #         with gr.Column(scale=1):
+        #             raw_task_dropdown = gr.Dropdown(label="Select Task")
+        #         with gr.Column(scale=1):
+        #             raw_step_dropdown = gr.Dropdown(label="Select Step")
+            
+        #     with gr.Row():
+        #         raw_call_details = gr.HTML()
             
-            def update_raw_task_dropdown(agent_name):
-                analyzed_traces = get_analyzed_traces(agent_name, "mlagentbench")
-                if not analyzed_traces:
-                    return gr.Dropdown(choices=[], label="Select Task"), gr.Dropdown(choices=[], label="Select Step"), f"No raw predictions data available for agent: {agent_name}."
-                task_ids = list(analyzed_traces.keys())
-                steps = analyzed_traces[task_ids[0]]['steps']
-                return gr.Dropdown(choices=task_ids, label="Select Task", value=task_ids[0]), gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), update_raw_call_details(agent_name, task_ids[0], 0)
-
-            def update_raw_step_dropdown(agent_name, task_id):
-                analyzed_traces = get_analyzed_traces(agent_name, "mlagentbench")
-                if not analyzed_traces or task_id not in analyzed_traces:
-                    return gr.Dropdown(choices=[], label="Select Step", value="No data available.")
-                steps = analyzed_traces[task_id]['steps']
-                return gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), format_call_info(steps[0], 0)
-
-            def update_raw_call_details(agent_name, task_id, step_index):
-                analyzed_traces = get_analyzed_traces(agent_name, "mlagentbench")
-                if not analyzed_traces or task_id not in analyzed_traces:
-                    return "No data available for this selection."
-                steps = analyzed_traces[task_id]['steps']
-                if step_index is None:
-                    return "Invalid step selection."
-                step = steps[step_index]
-                return format_call_info(step, step_index)
-
-            # Initialize the raw agent dropdown with all agents
-            demo.load(update_agent_dropdown, 
-                    inputs=[gr.Textbox(value="mlagentbench", visible=False), gr.Textbox(value="Overall Score", visible=False)], 
-                    outputs=[raw_agent_dropdown])
-            demo.load(update_raw_task_dropdown,
-                    inputs=[raw_agent_dropdown],
-                    outputs=[raw_task_dropdown, raw_step_dropdown])
-            demo.load(update_raw_call_details,
-                    inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown],
-                    outputs=[raw_call_details])
-
-            raw_agent_dropdown.change(update_raw_task_dropdown, 
-                                    inputs=[raw_agent_dropdown], 
-                                    outputs=[raw_task_dropdown, raw_step_dropdown, raw_call_details])
-            raw_task_dropdown.change(update_raw_step_dropdown, 
-                                    inputs=[raw_agent_dropdown, raw_task_dropdown], 
-                                    outputs=[raw_step_dropdown, raw_call_details])
-            raw_step_dropdown.change(update_raw_call_details, 
-                                    inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown], 
-                                    outputs=[raw_call_details])
+        #     def update_raw_task_dropdown(agent_name):
+        #         analyzed_traces = get_analyzed_traces(agent_name, "mlagentbench")
+        #         if not analyzed_traces:
+        #             return gr.Dropdown(choices=[], label="Select Task"), gr.Dropdown(choices=[], label="Select Step"), f"No raw predictions data available for agent: {agent_name}."
+        #         task_ids = list(analyzed_traces.keys())
+        #         steps = analyzed_traces[task_ids[0]]['steps']
+        #         return gr.Dropdown(choices=task_ids, label="Select Task", value=task_ids[0]), gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), update_raw_call_details(agent_name, task_ids[0], 0)
+
+        #     def update_raw_step_dropdown(agent_name, task_id):
+        #         analyzed_traces = get_analyzed_traces(agent_name, "mlagentbench")
+        #         if not analyzed_traces or task_id not in analyzed_traces:
+        #             return gr.Dropdown(choices=[], label="Select Step", value="No data available.")
+        #         steps = analyzed_traces[task_id]['steps']
+        #         return gr.Dropdown(choices=[(f"Step {i+1}", i) for i in range(len(steps))], label="Select Step", value=0), format_call_info(steps[0], 0)
+
+        #     def update_raw_call_details(agent_name, task_id, step_index):
+        #         analyzed_traces = get_analyzed_traces(agent_name, "mlagentbench")
+        #         if not analyzed_traces or task_id not in analyzed_traces:
+        #             return "No data available for this selection."
+        #         steps = analyzed_traces[task_id]['steps']
+        #         if step_index is None:
+        #             return "Invalid step selection."
+        #         step = steps[step_index]
+        #         return format_call_info(step, step_index)
+
+        #     # Initialize the raw agent dropdown with all agents
+        #     demo.load(update_agent_dropdown, 
+        #             inputs=[gr.Textbox(value="mlagentbench", visible=False), gr.Textbox(value="Overall Score", visible=False)], 
+        #             outputs=[raw_agent_dropdown])
+        #     demo.load(update_raw_task_dropdown,
+        #             inputs=[raw_agent_dropdown],
+        #             outputs=[raw_task_dropdown, raw_step_dropdown])
+        #     demo.load(update_raw_call_details,
+        #             inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown],
+        #             outputs=[raw_call_details])
+
+        #     raw_agent_dropdown.change(update_raw_task_dropdown, 
+        #                             inputs=[raw_agent_dropdown], 
+        #                             outputs=[raw_task_dropdown, raw_step_dropdown, raw_call_details])
+        #     raw_task_dropdown.change(update_raw_step_dropdown, 
+        #                             inputs=[raw_agent_dropdown, raw_task_dropdown], 
+        #                             outputs=[raw_step_dropdown, raw_call_details])
+        #     raw_step_dropdown.change(update_raw_call_details, 
+        #                             inputs=[raw_agent_dropdown, raw_task_dropdown, raw_step_dropdown], 
+        #                             outputs=[raw_call_details])
             
         
         with gr.Tab("About"):
@@ -1044,12 +1551,12 @@ async def main():
     # Download the results from the Hugging Face Hub
     # await asyncio.to_thread(download_latest_results)
 
-    # Check for new uploads and process them
+    # # Check for new uploads and process them
     # await check_and_process_uploads()
     
     scheduler = AsyncIOScheduler()
     scheduler.add_job(restart_space, "interval", hours=1)
-    scheduler.add_job(download_latest_results, "interval", hours=1)
+    # scheduler.add_job(download_latest_results, "interval", hours=1)
     # scheduler.add_job(check_and_process_uploads, "interval", hours=1)
     scheduler.start()