HARDE: Optimización de arneses de agentes para la detección de riesgos en tiempo de ejecución y el control de la ejecución

Lanzamiento del código para HARDE: Optimización de arneses de agentes para la detección de riesgos en tiempo de ejecución y el control de la ejecución.

El repositorio contiene dos familias de puntos de entrada complementarias:

• domains/: la línea base Meta-Harness y las dos etapas de HARDE para cada benchmark.
• personalized_harness/: adaptadores de benchmark, arneses de línea base, arneses aprendidos/personalizados y pipelines de evaluación.

Estructura del repositorio

HARDE/
├── domains/
│   ├── agentdyn/                                  # Meta-Harness baseline
│   ├── agentdyn_component_probe/                  # HARDE Stage I
│   ├── agentdyn_adaptive_component_search/        # HARDE Stage II
│   ├── agentsafetybench/                          # Meta-Harness baseline
│   ├── agentsafetybench_component_probe/          # HARDE Stage I
│   ├── agentsafetybench_adaptive_component_search/ # HARDE Stage II
│   ├── shade_arena/                               # Meta-Harness baseline
│   ├── shade_arena_component_probe/               # HARDE Stage I
│   └── shade_arena_adaptive_component_search/     # HARDE Stage II
├── personalized_harness/
│   ├── AgentDyn/
│   ├── AgentSafetyBench/
│   └── SHADE_v2/
├── .env.example
├── .gitignore
└── requirements.txt

Nomenclatura de dominios y etapas de HARDE

Para un benchmark llamado benchmark, los directorios siguen esta convención:

Directorio	Etapa del método	Punto de entrada principal
domains/benchmark/	Línea base Meta-Harness	meta_harness.py
domains/benchmark_component_probe/	HARDE Etapa I: sondeo de componentes	component_probe.py
domains/benchmark_adaptive_component_search/	HARDE Etapa II: búsqueda adaptativa de componentes	adaptive_component_search.py

La Etapa I sondea los componentes del arnés y produce una rúbrica a nivel de componente. La Etapa II consume esa rúbrica para seleccionar y optimizar un componente de forma adaptativa durante la búsqueda. En este repositorio, benchmark es uno de agentdyn, agentsafetybench o shade_arena.

Configuración

Se recomienda Python 3.10 o superior.

conda create -n HARDE python=3.10
conda activate HARDE
pip install -r requirements.txt
cp .env.example .env
cp model_config.example.yaml model_config.yaml

# Edit .env, then export its values into the current shell.
set -a
source .env
set +a

Benchmarks externos

El código y los conjuntos de datos de benchmarks de terceros no están incluidos en el repositorio. Clona los benchmarks que necesites en la raíz del repositorio usando los nombres de directorio exactos que se indican a continuación:

git clone https://github.com/leolee99/AgentDyn.git AgentDyn
git clone https://github.com/jkutaso/SHADE-Arena.git SHADE-Arena
git clone https://github.com/thu-coai/Agent-SafetyBench.git Agent-SafetyBench

Fuentes de datos adicionales:

• Datos de Agent-SafetyBench: https://huggingface.co/datasets/thu-coai/Agent-SafetyBench

Los adaptadores resuelven estos repositorios en relación con la raíz de HARDE. Estructura esperada:

HARDE/
├── AgentDyn/
├── SHADE-Arena/
├── Agent-SafetyBench/
├── domains/
└── personalized_harness/

Ejecución del código

Los comandos y las opciones detallados específicos de cada benchmark están documentados en el README dentro del directorio correspondiente bajo domains/. Los ejemplos de evaluación con arnés fijo están documentados en personalized_harness/README.md.

Los siguientes ejemplos de SHADE-Arena muestran el flujo de ejecución completo para cada método.

Línea base Meta-Harness

Meta-Harness optimiza directamente el arnés completo durante tres iteraciones y luego evalúa el arnés seleccionado en el conjunto de prueba reservado:

python domains/shade_arena/meta_harness.py \
  --run-name shade_meta_seed0 \
  --fresh \
  --iterations 3 \
  --seed 0 \
  --run-final-test

Los resultados se escriben en domains/shade_arena/runs/shade_meta_seed0/.

Propuesta de arnés de una sola vez

Esta línea base evalúa el arnés de benchmark sin modificar, propone un arnés personalizado en una única llamada al LLM y evalúa esa propuesta en las mismas tareas de SHADE-Arena. No realiza búsqueda iterativa:

python personalized_harness/shade_v2_pipeline.py \
  --model_config model_config.yaml \
  --tasks spam_filter_update \
  --repeat 1 \
  --output_harness personalized_harness/SHADE_v2/harnesses/one_shot_proposal.py \
  --output_dir personalized_harness/SHADE_v2/output_one_shot

Sin las opciones --skip_generate, --skip_base ni --skip_personalized, este comando ejecuta la cadena completa:

base-harness evaluation → one-shot harness proposal → proposed-harness evaluation → summary

HARDE

HARDE primero sondea componentes individuales del arnés en la Etapa I:

python domains/shade_arena_component_probe/component_probe.py \
  --run-name shade_probe_seed0 \
  --seed 0

La Etapa I escribe la guía del arnés generada en:

domains/shade_arena_component_probe/runs/shade_probe_seed0/experience/module_rubric.md

La Etapa II consume esa guía, selecciona de forma adaptativa un componente en cada iteración, ejecuta tres iteraciones de búsqueda y evalúa el arnés final seleccionado:

python domains/shade_arena_adaptive_component_search/adaptive_component_search.py \
  --run-name shade_adaptive_seed0 \
  --seed 0 \
  --iterations 3 \
  --rubric domains/shade_arena_component_probe/runs/shade_probe_seed0/experience/module_rubric.md \
  --initial-components initial_components/full_trajectory_monitor \
  --run-final-test

Citación

Los metadatos de citación se añadirán con la publicación del artículo.