hide swebench lite and mlagentbench

app.py

@@ -1078,338 +1078,338 @@ with gr.Blocks(theme=my_theme, css='css.css', title="HAL: Holistic Agent Leaderb
         
         
         
-        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:",
-                        ),
-                        hide_columns=config.SWEBENCH_HIDE_COLUMNS,
-                        search_columns=config.SWEBENCH_SEARCH_COLUMNS,
-                    )
-                    gr.Markdown("""*Error ranges span from the lowest to highest observed values in repeated runs.*""", elem_classes=["text-right"])
-            with gr.Row():
-                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"]))
+        # 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:",
+        #                 ),
+        #                 hide_columns=config.SWEBENCH_HIDE_COLUMNS,
+        #                 search_columns=config.SWEBENCH_SEARCH_COLUMNS,
+        #             )
+        #             gr.Markdown("""*Error ranges span from the lowest to highest observed values in repeated runs.*""", elem_classes=["text-right"])
+        #     with gr.Row():
+        #         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'),
-                'SWE-bench Lite'
-            ),
-            outputs=[task_success_heatmap]
-            )
-
-            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()
+        #     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'),
+        #         'SWE-bench Lite'
+        #     ),
+        #     outputs=[task_success_heatmap]
+        #     )
+
+        #     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()
+        #             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])
+        #         # 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)])
+        #         # 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()
+        #     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])
+        #         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=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:",
-                        ),
-                        hide_columns=config.MLAGENTBENCH_HIDE_COLUMNS,
-                        search_columns=config.MLAGENTBENCH_SEARCH_COLUMNS,
-                    )
-                    gr.Markdown("""*Error ranges span from the lowest to highest observed values in repeated runs.*""", elem_classes=["text-right"])
-            with gr.Row():
-                gr.Markdown("### Accuracy vs. Cost for MLAgentBench agents")
-            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"]))
+        # 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=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:",
+        #                 ),
+        #                 hide_columns=config.MLAGENTBENCH_HIDE_COLUMNS,
+        #                 search_columns=config.MLAGENTBENCH_SEARCH_COLUMNS,
+        #             )
+        #             gr.Markdown("""*Error ranges span from the lowest to highest observed values in repeated runs.*""", elem_classes=["text-right"])
+        #     with gr.Row():
+        #         gr.Markdown("### Accuracy vs. Cost for MLAgentBench agents")
+        #     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.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]
-            # )
-
-            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()
+        #     # 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]
+        #     # )
+
+        #     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()
+        #         #     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])
+        #         # # 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)])
+        #         # # 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()
+        #     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])   
+        #         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("About"):
             gr.Markdown((Path(__file__).parent / "about.md").read_text())