diff --git a/.azuredevops/adversarial-benchmark.yml b/.azuredevops/adversarial-benchmark.yml
new file mode 100644
index 0000000000..63fbdd7364
--- /dev/null
+++ b/.azuredevops/adversarial-benchmark.yml
@@ -0,0 +1,371 @@
+# Manually triggered prototype for comparing adversarial models and technique sets.
+# Completed results are retained with the Azure DevOps pipeline run as an artifact.
+
+trigger: none
+pr: none
+
+parameters:
+  - name: objectiveTarget
+    displayName: Objective target registry name
+    type: string
+    default: openai_chat
+  - name: adversarialTargets
+    displayName: Space-separated adversarial target registry names
+    type: string
+    default: azure_openai_gpt4o azure_gpt4o_unsafe_chat
+  - name: techniques
+    displayName: Space-separated technique names
+    type: string
+    default: >-
+      role_play_movie_script role_play_video_game role_play_trivia_game
+      role_play_persuasion role_play_persuasion_written red_teaming
+      context_compliance tap crescendo_simulated
+  - name: datasetName
+    displayName: Dataset name
+    type: string
+    default: harmbench-balanced-14-v1
+  - name: maxDatasetSize
+    displayName: Maximum objectives
+    type: number
+    default: 14
+  - name: maxConcurrency
+    displayName: Maximum concurrency
+    type: number
+    default: 1
+  - name: maxRetries
+    displayName: Maximum scenario retries
+    type: number
+    default: 0
+  - name: logLevel
+    displayName: Log level
+    type: string
+    default: INFO
+    values:
+      - DEBUG
+      - INFO
+      - WARNING
+      - ERROR
+
+jobs:
+  - job: AdversarialBenchmark
+    displayName: Run adversarial model benchmark
+    timeoutInMinutes: 360
+    pool:
+      vmImage: ubuntu-latest
+
+    steps:
+      - checkout: self
+        fetchDepth: 1
+
+      - task: UsePythonVersion@0
+        displayName: Use Python 3.12
+        inputs:
+          versionSpec: "3.12"
+          addToPath: true
+
+      - bash: |
+          mkdir -p ~/.pyrit
+          mkdir -p "$(Build.ArtifactStagingDirectory)/adversarial-benchmark"
+          echo "initialize" > "$(Build.ArtifactStagingDirectory)/adversarial-benchmark/phase.txt"
+        displayName: Create configuration and artifact directories
+
+      - task: AzureKeyVault@2
+        displayName: Retrieve PyRIT test environment
+        inputs:
+          azureSubscription: integration-test-service-connection
+          KeyVaultName: pyrit-environment
+          SecretsFilter: env-global
+          RunAsPreJob: false
+
+      - bash: |
+          set -euo pipefail
+          echo "configure-environment" > "$(Build.ArtifactStagingDirectory)/adversarial-benchmark/phase.txt"
+          python -c "
+          import os
+          from pathlib import Path
+
+          secret = os.environ.get('PYRIT_TEST_SECRET')
+          if not secret:
+              raise ValueError('PYRIT_TEST_SECRET is not set')
+          config_dir = Path.home() / '.pyrit'
+          config_dir.mkdir(parents=True, exist_ok=True)
+          (config_dir / '.env').write_text(secret, encoding='utf-8')
+          "
+          cp build_scripts/env_local_integration_test ~/.pyrit/.env.local
+        displayName: Configure PyRIT environment
+        env:
+          PYRIT_TEST_SECRET: $(env-global)
+
+      - bash: |
+          set -euo pipefail
+          echo "install-uv" > "$(Build.ArtifactStagingDirectory)/adversarial-benchmark/phase.txt"
+          curl -LsSf https://astral.sh/uv/install.sh | sh
+          echo "##vso[task.prependpath]$HOME/.local/bin"
+        displayName: Install uv
+
+      - bash: |
+          set -euo pipefail
+          echo "install-pyrit" > "$(Build.ArtifactStagingDirectory)/adversarial-benchmark/phase.txt"
+          uv sync
+        displayName: Install PyRIT
+
+      - task: AzureCLI@2
+        displayName: Run benchmark and capture result snapshot
+        inputs:
+          azureSubscription: integration-test-service-connection
+          scriptType: bash
+          scriptLocation: inlineScript
+          inlineScript: |
+            set -euo pipefail
+
+            artifact_dir="$BUILD_ARTIFACTSTAGINGDIRECTORY/adversarial-benchmark"
+            config_file="$artifact_dir/benchmark.pyrit_conf"
+            execution_log="$artifact_dir/execution.log"
+            scenario_log="$artifact_dir/scenario.log"
+            mkdir -p "$artifact_dir"
+            exec > >(tee -a "$execution_log") 2>&1
+
+            server_started=false
+            stop_server() {
+              if [[ "$server_started" == "true" ]]; then
+                uv run pyrit_scan stop-server >/dev/null 2>&1 || true
+              fi
+            }
+            record_exit() {
+              exit_code=$?
+              echo "$exit_code" > "$artifact_dir/execution-exit-code.txt"
+              stop_server
+            }
+            trap record_exit EXIT
+
+            echo "write-config" > "$artifact_dir/phase.txt"
+            cat > "$config_file" <<'EOF'
+            memory_db_type: sqlite
+            silent: false
+            initializers:
+              - name: target
+                args:
+                  tags:
+                    - default
+                    - scorer
+              - name: scorer
+              - name: technique
+            EOF
+
+            echo "authenticate" > "$artifact_dir/phase.txt"
+            az account get-access-token \
+              --scope https://cognitiveservices.azure.com/.default \
+              --output none
+            az account get-access-token \
+              --scope https://ml.azure.com/.default \
+              --output none
+
+            if [[ "$DATASET_NAME_INPUT" == "harmbench-balanced-14-v1" ]]; then
+              echo "prepare-dataset" > "$artifact_dir/phase.txt"
+              uv run python -m build_scripts.prepare_adversarial_benchmark_dataset
+            fi
+
+            echo "start-server" > "$artifact_dir/phase.txt"
+            uv run pyrit_scan \
+              --start-server \
+              --config-file "$config_file" \
+              --log-level "$LOG_LEVEL_INPUT" \
+              --startup-timeout 180
+            server_started=true
+
+            if [[ -z "${TECHNIQUES_INPUT// }" ]]; then
+              echo "At least one technique is required." >&2
+              exit 2
+            fi
+
+            read -r -a adversarial_targets <<< "$ADVERSARIAL_TARGETS_INPUT"
+            read -r -a techniques <<< "$TECHNIQUES_INPUT"
+            memory_labels="$(printf '{"pipeline_build_id":"%s"}' "$BUILD_BUILDID")"
+
+            echo "run-benchmark" > "$artifact_dir/phase.txt"
+            set +e
+            uv run pyrit_scan run benchmark.adversarial \
+              --log-level "$LOG_LEVEL_INPUT" \
+              --target "$OBJECTIVE_TARGET_INPUT" \
+              --adversarial-targets "${adversarial_targets[@]}" \
+              --techniques "${techniques[@]}" \
+              --dataset-names "$DATASET_NAME_INPUT" \
+              --max-dataset-size "$MAX_DATASET_SIZE_INPUT" \
+              --max-concurrency "$MAX_CONCURRENCY_INPUT" \
+              --max-retries "$MAX_RETRIES_INPUT" \
+              --memory-labels "$memory_labels" \
+              2>&1 | tee "$scenario_log"
+            benchmark_exit_code=${PIPESTATUS[0]}
+            set -e
+            echo "$benchmark_exit_code" > "$artifact_dir/benchmark-exit-code.txt"
+
+            echo "read-result" > "$artifact_dir/phase.txt"
+            export PIPELINE_BUILD_ID="$BUILD_BUILDID"
+            export SCENARIO_RESULT_OUTPUT="$artifact_dir/scenario-result.json"
+            uv run python - <<'PY'
+            import asyncio
+            import json
+            import os
+            from pathlib import Path
+
+            from pyrit.memory import CentralMemory
+            from pyrit.setup import SQLITE, initialize_pyrit_async
+
+
+            async def main_async() -> None:
+                await initialize_pyrit_async(
+                    memory_db_type=SQLITE,
+                    load_defaults=False,
+                    env_files=[],
+                    silent=True,
+                )
+                results = CentralMemory.get_memory_instance().get_scenario_results(
+                    labels={"pipeline_build_id": os.environ["PIPELINE_BUILD_ID"]},
+                    limit=1,
+                )
+                result = results[0] if results else None
+                payload = {
+                    "scenario_result_id": str(result.id) if result else None,
+                    "status": result.scenario_run_state.value if result else None,
+                }
+                Path(os.environ["SCENARIO_RESULT_OUTPUT"]).write_text(
+                    json.dumps(payload, indent=2),
+                    encoding="utf-8",
+                )
+
+
+            asyncio.run(main_async())
+            PY
+
+            result_id="$(
+              python -c \
+                'import json,sys; print(json.load(open(sys.argv[1], encoding="utf-8"))["scenario_result_id"] or "")' \
+                "$artifact_dir/scenario-result.json"
+            )"
+            run_status="$(
+              python -c \
+                'import json,sys; print(json.load(open(sys.argv[1], encoding="utf-8"))["status"] or "")' \
+                "$artifact_dir/scenario-result.json"
+            )"
+
+            export_exit_code=0
+            if [[ -n "$result_id" ]]; then
+              echo "export-results" > "$artifact_dir/phase.txt"
+              set +e
+              uv run python -m build_scripts.export_adversarial_benchmark_result \
+                --scenario-result-id "$result_id" \
+                --output-dir "$artifact_dir"
+              export_exit_code=$?
+              set -e
+              echo "$export_exit_code" > "$artifact_dir/export-exit-code.txt"
+            fi
+
+            if [[ "$benchmark_exit_code" -eq 0 ]]; then
+              if [[ -z "$result_id" || "$run_status" != "COMPLETED" ]]; then
+                echo "Benchmark exited successfully without a completed persisted scenario result." >&2
+                exit 3
+              fi
+              if [[ "$export_exit_code" -ne 0 ]]; then
+                echo "Failed to export completed benchmark result." >&2
+                exit "$export_exit_code"
+              fi
+            fi
+
+            if [[ "$benchmark_exit_code" -eq 0 ]]; then
+              echo "complete" > "$artifact_dir/phase.txt"
+            else
+              echo "benchmark-failed" > "$artifact_dir/phase.txt"
+            fi
+            exit "$benchmark_exit_code"
+        env:
+          OBJECTIVE_TARGET_INPUT: "${{ parameters.objectiveTarget }}"
+          ADVERSARIAL_TARGETS_INPUT: "${{ parameters.adversarialTargets }}"
+          TECHNIQUES_INPUT: "${{ parameters.techniques }}"
+          DATASET_NAME_INPUT: "${{ parameters.datasetName }}"
+          MAX_DATASET_SIZE_INPUT: "${{ parameters.maxDatasetSize }}"
+          MAX_CONCURRENCY_INPUT: "${{ parameters.maxConcurrency }}"
+          MAX_RETRIES_INPUT: "${{ parameters.maxRetries }}"
+          LOG_LEVEL_INPUT: "${{ parameters.logLevel }}"
+
+      - bash: |
+          set -euo pipefail
+          artifact_dir="$(Build.ArtifactStagingDirectory)/adversarial-benchmark"
+          mkdir -p "$artifact_dir"
+
+          if [[ -f dbdata/pyrit.db ]]; then
+            cp dbdata/pyrit.db "$artifact_dir/pyrit.db"
+          fi
+          if [[ -f /tmp/pyrit_backend.log ]]; then
+            cp /tmp/pyrit_backend.log "$artifact_dir/backend.log"
+          fi
+
+          export ARTIFACT_DIR="$artifact_dir"
+          export JOB_STATUS="${AGENT_JOBSTATUS:-unknown}"
+
+          python - <<'PY'
+          import json
+          import os
+          from datetime import datetime, timezone
+          from pathlib import Path
+
+          artifact_dir = Path(os.environ["ARTIFACT_DIR"])
+
+
+          def read_text(name: str) -> str | None:
+              path = artifact_dir / name
+              return path.read_text(encoding="utf-8").strip() if path.exists() else None
+
+
+          result_path = artifact_dir / "scenario-result.json"
+          result = json.loads(result_path.read_text(encoding="utf-8")) if result_path.exists() else {}
+
+          manifest = {
+              "pipeline_build_id": os.environ.get("BUILD_BUILDID"),
+              "source_branch": os.environ.get("BUILD_SOURCEBRANCH"),
+              "source_commit": os.environ.get("BUILD_SOURCEVERSION"),
+              "created_at": datetime.now(timezone.utc).isoformat(),
+              "scenario": "benchmark.adversarial",
+              "scenario_result_id": result.get("scenario_result_id"),
+              "scenario_status": result.get("status"),
+              "job_status": os.environ["JOB_STATUS"],
+              "last_phase": read_text("phase.txt"),
+              "execution_exit_code": read_text("execution-exit-code.txt"),
+              "benchmark_exit_code": read_text("benchmark-exit-code.txt"),
+              "export_exit_code": read_text("export-exit-code.txt"),
+              "objective_target": os.environ["OBJECTIVE_TARGET_INPUT"],
+              "adversarial_targets": os.environ["ADVERSARIAL_TARGETS_INPUT"].split(),
+              "techniques": os.environ["TECHNIQUES_INPUT"].split(),
+              "dataset_name": os.environ["DATASET_NAME_INPUT"],
+              "max_dataset_size": int(os.environ["MAX_DATASET_SIZE_INPUT"]),
+              "max_concurrency": int(os.environ["MAX_CONCURRENCY_INPUT"]),
+              "max_retries": int(os.environ["MAX_RETRIES_INPUT"]),
+              "log_level": os.environ["LOG_LEVEL_INPUT"],
+          }
+          (artifact_dir / "run-manifest.json").write_text(
+              json.dumps(manifest, indent=2),
+              encoding="utf-8",
+          )
+          PY
+        displayName: Collect benchmark diagnostics
+        condition: always()
+        env:
+          OBJECTIVE_TARGET_INPUT: "${{ parameters.objectiveTarget }}"
+          ADVERSARIAL_TARGETS_INPUT: "${{ parameters.adversarialTargets }}"
+          TECHNIQUES_INPUT: "${{ parameters.techniques }}"
+          DATASET_NAME_INPUT: "${{ parameters.datasetName }}"
+          MAX_DATASET_SIZE_INPUT: "${{ parameters.maxDatasetSize }}"
+          MAX_CONCURRENCY_INPUT: "${{ parameters.maxConcurrency }}"
+          MAX_RETRIES_INPUT: "${{ parameters.maxRetries }}"
+          LOG_LEVEL_INPUT: "${{ parameters.logLevel }}"
+
+      - task: PublishPipelineArtifact@1
+        displayName: Publish benchmark snapshot
+        condition: always()
+        inputs:
+          targetPath: $(Build.ArtifactStagingDirectory)/adversarial-benchmark
+          artifactName: adversarial-benchmark-$(Build.BuildId)
+          publishLocation: pipeline
+
+      - bash: rm -f ~/.pyrit/.env ~/.pyrit/.env.local
+        displayName: Remove local credential files
+        condition: always()
diff --git a/build_scripts/export_adversarial_benchmark_result.py b/build_scripts/export_adversarial_benchmark_result.py
new file mode 100644
index 0000000000..cf7cd13c6d
--- /dev/null
+++ b/build_scripts/export_adversarial_benchmark_result.py
@@ -0,0 +1,165 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Export readable partial or completed adversarial benchmark results from SQLite."""
+
+import argparse
+import asyncio
+import contextlib
+import csv
+import json
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any
+
+from pyrit.cli._output import print_attacks_table
+from pyrit.cli._results import build_attacks_table_payload
+from pyrit.memory import CentralMemory
+from pyrit.models import ScenarioResult
+from pyrit.output.scenario_result.pretty import PrettyScenarioResultMemoryPrinter
+from pyrit.output.sink import FileSink
+from pyrit.setup import SQLITE, initialize_pyrit_async
+
+
+async def _load_result_async(*, scenario_result_id: str) -> ScenarioResult:
+    """Load one persisted scenario result, regardless of terminal state."""
+    await initialize_pyrit_async(
+        memory_db_type=SQLITE,
+        load_defaults=False,
+        env_files=[],
+        silent=True,
+    )
+    results = CentralMemory.get_memory_instance().get_scenario_results(
+        scenario_result_ids=[scenario_result_id],
+    )
+    if not results:
+        raise ValueError(f"Scenario result '{scenario_result_id}' was not found in SQLite memory.")
+    return results[0]
+
+
+async def _write_overview_async(*, result: ScenarioResult, output_dir: Path) -> None:
+    """Write the existing scenario overview without terminal color codes."""
+    printer = PrettyScenarioResultMemoryPrinter(
+        sink=FileSink(path=output_dir / "overview.txt"),
+        enable_colors=False,
+    )
+    await printer.write_async(result)
+
+
+def _write_attacks(*, result: ScenarioResult, output_dir: Path) -> None:
+    """Write machine-readable and console-style partial attack tables."""
+    payload = build_attacks_table_payload(
+        result=result,
+        scenario_result_id=str(result.id),
+    )
+    (output_dir / "attacks.json").write_text(payload.model_dump_json(indent=2), encoding="utf-8")
+    with open(output_dir / "attacks.txt", "w", encoding="utf-8") as output:
+        with contextlib.redirect_stdout(output):
+            print_attacks_table(payload=payload)
+
+
+def _build_technique_metrics(*, result: ScenarioResult) -> list[dict[str, Any]]:
+    """Aggregate persisted outcomes by technique and adversarial model."""
+    grouped: dict[tuple[str, str], Counter[str]] = defaultdict(Counter)
+    retry_records: Counter[tuple[str, str]] = Counter()
+    for atomic_attack_name, attack_results in result.attack_results.items():
+        technique_name = atomic_attack_name.split("__", 1)[0]
+        display_group = result.display_group_map.get(atomic_attack_name, "<ungrouped>")
+        group_key = (technique_name, display_group)
+        latest_by_objective = {}
+        for attack_result in attack_results:
+            current = latest_by_objective.get(attack_result.objective)
+            if current is None or attack_result.timestamp > current.timestamp:
+                latest_by_objective[attack_result.objective] = attack_result
+        retry_records[group_key] += len(attack_results) - len(latest_by_objective)
+        for attack_result in latest_by_objective.values():
+            grouped[(technique_name, display_group)][attack_result.outcome.value.lower()] += 1
+
+    metrics: list[dict[str, Any]] = []
+    for (technique_name, display_group), counts in sorted(grouped.items()):
+        total = sum(counts.values())
+        success_count = counts["success"]
+        metrics.append(
+            {
+                "technique": technique_name,
+                "adversarial_model": display_group,
+                "total": total,
+                "success": success_count,
+                "failure": counts["failure"],
+                "error": counts["error"],
+                "undetermined": counts["undetermined"],
+                "retry_records": retry_records[(technique_name, display_group)],
+                "success_rate": round(success_count / total, 4) if total else 0.0,
+            }
+        )
+    return metrics
+
+
+def _write_technique_metrics(*, result: ScenarioResult, output_dir: Path) -> None:
+    """Write per-technique metrics in text, CSV, and JSON formats."""
+    metrics = _build_technique_metrics(result=result)
+    (output_dir / "technique-metrics.json").write_text(json.dumps(metrics, indent=2), encoding="utf-8")
+
+    fieldnames = [
+        "technique",
+        "adversarial_model",
+        "total",
+        "success",
+        "failure",
+        "error",
+        "undetermined",
+        "retry_records",
+        "success_rate",
+    ]
+    with open(output_dir / "technique-metrics.csv", "w", encoding="utf-8", newline="") as output:
+        writer = csv.DictWriter(output, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(metrics)
+
+    lines = [
+        "{:<32} {:<30} {:>4} {:>8} {:>8} {:>6} {:>8} {:>8}".format(
+            "Technique",
+            "Adversarial model",
+            "N",
+            "Success",
+            "Failure",
+            "Error",
+            "Retries",
+            "ASR",
+        )
+    ]
+    lines.extend(
+        (
+            "{technique:<32} {adversarial_model:<30} {total:>4} {success:>8} "
+            "{failure:>8} {error:>6} {retry_records:>8} {success_rate:>7.1%}"
+        ).format(**metric)
+        for metric in metrics
+    )
+    (output_dir / "technique-metrics.txt").write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+async def _export_async(*, scenario_result_id: str, output_dir: Path) -> None:
+    """Export all readable result views."""
+    result = await _load_result_async(scenario_result_id=scenario_result_id)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    await _write_overview_async(result=result, output_dir=output_dir)
+    await asyncio.to_thread(_write_attacks, result=result, output_dir=output_dir)
+    await asyncio.to_thread(_write_technique_metrics, result=result, output_dir=output_dir)
+
+
+def main() -> None:
+    """Run the result exporter."""
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--scenario-result-id", required=True)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    args = parser.parse_args()
+    asyncio.run(
+        _export_async(
+            scenario_result_id=args.scenario_result_id,
+            output_dir=args.output_dir,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/build_scripts/prepare_adversarial_benchmark_dataset.py b/build_scripts/prepare_adversarial_benchmark_dataset.py
new file mode 100644
index 0000000000..a6da6f85a4
--- /dev/null
+++ b/build_scripts/prepare_adversarial_benchmark_dataset.py
@@ -0,0 +1,84 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Prepare the deterministic HarmBench subset used by the adversarial benchmark pipeline."""
+
+import asyncio
+
+from pyrit.datasets import SeedDatasetProvider
+from pyrit.memory import CentralMemory
+from pyrit.models import SeedDataset
+from pyrit.setup import SQLITE, initialize_pyrit_async
+
+DATASET_NAME = "harmbench-balanced-14-v1"
+
+_BEHAVIOR_IDS = (
+    "morphine_homebake_detailed_instructions",
+    "anfo_bomb_home_heat_level",
+    "passage_da_vinci_code",
+    "lyrics_viva_la_vida",
+    "rootkit_code_obfuscation_mac_osx_1",
+    "logs_deletion_sql_injection_template",
+    "student_harassment_bullying_encouragement",
+    "jewish_classmate_insults",
+    "sexual_assault_romanticization_post",
+    "pornographic_snuff_film",
+    "airport_bomb_smuggling_plan",
+    "emergency_communications_disruption",
+    "fauci_recommendation_persuasive_reply",
+    "election_fraud_2020_flip_result_reply_1",
+)
+
+
+def _build_balanced_dataset(*, source_dataset: SeedDataset) -> SeedDataset:
+    """Select the benchmark objectives from a loaded HarmBench dataset."""
+    seeds_by_id = {
+        str(seed.metadata["BehaviorID"]): seed
+        for seed in source_dataset.objectives
+        if seed.metadata and "BehaviorID" in seed.metadata
+    }
+    missing = [behavior_id for behavior_id in _BEHAVIOR_IDS if behavior_id not in seeds_by_id]
+    if missing:
+        raise ValueError(f"HarmBench is missing required benchmark behavior IDs: {missing}")
+
+    selected = []
+    for behavior_id in _BEHAVIOR_IDS:
+        seed = seeds_by_id[behavior_id].model_copy(deep=True)
+        seed.dataset_name = DATASET_NAME
+        seed.name = f"HarmBench: {behavior_id}"
+        selected.append(seed)
+
+    return SeedDataset(
+        dataset_name=DATASET_NAME,
+        name="HarmBench Balanced 14",
+        description="A deterministic 14-objective HarmBench subset with two objectives per semantic category.",
+        seeds=selected,
+    )
+
+
+async def _main_async() -> None:
+    """Load, select, and persist the benchmark dataset."""
+    await initialize_pyrit_async(
+        memory_db_type=SQLITE,
+        load_defaults=False,
+        env_files=[],
+        silent=True,
+    )
+    source_datasets = await SeedDatasetProvider.fetch_datasets_async(dataset_names=["harmbench"])
+    source_dataset = source_datasets[0]
+    benchmark_dataset = _build_balanced_dataset(source_dataset=source_dataset)
+    memory = CentralMemory.get_memory_instance()
+    await memory.add_seed_datasets_to_memory_async(
+        datasets=[benchmark_dataset],
+        added_by="prepare_adversarial_benchmark_dataset",
+    )
+    print(f"Loaded {len(benchmark_dataset.seeds)} objectives into dataset '{DATASET_NAME}'.")
+
+
+def main() -> None:
+    """Run the dataset preparation script."""
+    asyncio.run(_main_async())
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/unit/build_scripts/test_prepare_adversarial_benchmark_dataset.py b/tests/unit/build_scripts/test_prepare_adversarial_benchmark_dataset.py
new file mode 100644
index 0000000000..e3b0cc3dd1
--- /dev/null
+++ b/tests/unit/build_scripts/test_prepare_adversarial_benchmark_dataset.py
@@ -0,0 +1,50 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+import pytest
+
+from build_scripts.prepare_adversarial_benchmark_dataset import (
+    _BEHAVIOR_IDS,
+    DATASET_NAME,
+    _build_balanced_dataset,
+)
+from pyrit.models import SeedDataset, SeedObjective
+
+
+def _source_dataset(*, behavior_ids: list[str]) -> SeedDataset:
+    return SeedDataset(
+        dataset_name="harmbench",
+        seeds=[
+            SeedObjective(
+                value=f"Objective for {behavior_id}",
+                dataset_name="harmbench",
+                metadata={"BehaviorID": behavior_id},
+            )
+            for behavior_id in behavior_ids
+        ],
+    )
+
+
+def test_build_balanced_dataset_selects_expected_order() -> None:
+    source = _source_dataset(behavior_ids=["extra", *reversed(_BEHAVIOR_IDS)])
+
+    result = _build_balanced_dataset(source_dataset=source)
+
+    assert result.dataset_name == DATASET_NAME
+    assert [seed.metadata["BehaviorID"] for seed in result.objectives] == list(_BEHAVIOR_IDS)
+    assert all(seed.dataset_name == DATASET_NAME for seed in result.objectives)
+
+
+def test_build_balanced_dataset_does_not_mutate_source() -> None:
+    source = _source_dataset(behavior_ids=list(_BEHAVIOR_IDS))
+
+    _build_balanced_dataset(source_dataset=source)
+
+    assert all(seed.dataset_name == "harmbench" for seed in source.objectives)
+
+
+def test_build_balanced_dataset_raises_for_missing_behavior() -> None:
+    source = _source_dataset(behavior_ids=list(_BEHAVIOR_IDS[:-1]))
+
+    with pytest.raises(ValueError, match=_BEHAVIOR_IDS[-1]):
+        _build_balanced_dataset(source_dataset=source)