evaluation_id string | scenario_id string | shuffle_seed int64 | roles list | fragments list | distractor_id string | reference_need_sets unknown | role_assignment_prompt string | prompt_writing_prompt string |
|---|---|---|---|---|---|---|---|---|
pg_000__seed_1 | pg_000 | 1 | [
"coder",
"reviewer"
] | [
{
"id": "f1",
"text": "After finding a bug, submit it to a **fresh** reviewer for review. Do not review your own report.\n\n**After the review returns:** execute all action steps in the reviewer's output.",
"is_distractor": false
},
{
"id": "f2",
"text": "Claude responds well to clear, expli... | f2 | {
"coder": [
"f5",
"f6",
"f7",
"f1"
],
"reviewer": [
"f5",
"f3",
"f4"
]
} | I need you to set up a 2-agent pipeline for bug bounty.
The two roles are coder and reviewer: coder is responsible for finding bugs, reviewer is responsible for judging whether what the coder found counts as a bug.
After each bug the coder finds, they must spawn a **fresh** reviewer to evaluate it — this drives the loo... | I need you to set up a 2-agent pipeline for bug bounty.
The two roles are coder and reviewer: coder is responsible for finding bugs, reviewer is responsible for judging whether what the coder found counts as a bug.
After each bug the coder finds, they must spawn a **fresh** reviewer to evaluate it — this drives the loo... |
pg_000__seed_42 | pg_000 | 42 | [
"coder",
"reviewer"
] | [
{
"id": "f1",
"text": "This project has been running stably for many years — any obvious fatal bug would have killed it long ago. So:\n\n- Don't report problems that are obvious at a glance (e.g. \"some map is never erased\") — if it were that obvious, the project team would have fixed it themselves\n- Trul... | f5 | {
"coder": [
"f6",
"f3",
"f1",
"f2"
],
"reviewer": [
"f6",
"f7",
"f4"
]
} | I need you to set up a 2-agent pipeline for bug bounty.
The two roles are coder and reviewer: coder is responsible for finding bugs, reviewer is responsible for judging whether what the coder found counts as a bug.
After each bug the coder finds, they must spawn a **fresh** reviewer to evaluate it — this drives the loo... | I need you to set up a 2-agent pipeline for bug bounty.
The two roles are coder and reviewer: coder is responsible for finding bugs, reviewer is responsible for judging whether what the coder found counts as a bug.
After each bug the coder finds, they must spawn a **fresh** reviewer to evaluate it — this drives the loo... |
pg_001__seed_1 | pg_001 | 1 | [
"coder",
"reviewer"
] | [
{
"id": "f1",
"text": "After finding a bug, submit it to a **fresh** reviewer for review. Do not review your own report.\n\n**After the review returns:** execute all action steps in the reviewer's output. Then immediately go back to step 1: re-read ideas.xml and pick the next idea by UCB to keep working. Do... | f2 | {
"coder": [
"f5",
"f3",
"f7",
"f1"
],
"reviewer": [
"f5",
"f4",
"f6"
]
} | I need you to set up a 2-agent pipeline for bug bounty. The two roles are coder and reviewer: coder is responsible for finding bugs, reviewer is responsible for judging whether what the coder found counts as a bug. The flow is roughly:
```
WHILE TRUE:
1. coder picks an idea it likes and explores it deeply, or appe... | I need you to set up a 2-agent pipeline for bug bounty. The two roles are coder and reviewer: coder is responsible for finding bugs, reviewer is responsible for judging whether what the coder found counts as a bug. The flow is roughly:
```
WHILE TRUE:
1. coder picks an idea it likes and explores it deeply, or appe... |
pg_001__seed_42 | pg_001 | 42 | [
"coder",
"reviewer"
] | [
{
"id": "f1",
"text": "This project has been running stably for many years — any obvious fatal bug would have killed it long ago. So:\n\n- Don't report problems that are obvious at a glance (e.g. \"some map is never erased\") — if it were that obvious, the project team would have fixed it themselves\n- Trul... | f5 | {
"coder": [
"f6",
"f7",
"f1",
"f2"
],
"reviewer": [
"f6",
"f4",
"f3"
]
} | I need you to set up a 2-agent pipeline for bug bounty. The two roles are coder and reviewer: coder is responsible for finding bugs, reviewer is responsible for judging whether what the coder found counts as a bug. The flow is roughly:
```
WHILE TRUE:
1. coder picks an idea it likes and explores it deeply, or appe... | I need you to set up a 2-agent pipeline for bug bounty. The two roles are coder and reviewer: coder is responsible for finding bugs, reviewer is responsible for judging whether what the coder found counts as a bug. The flow is roughly:
```
WHILE TRUE:
1. coder picks an idea it likes and explores it deeply, or appe... |
pg_002__seed_1 | pg_002 | 1 | [
"dispatcher",
"coder",
"reviewer"
] | [
{
"id": "f1",
"text": "Your only job is to alternate calls to the coder and reviewer agents, driving the explore → write → review → improve loop.\n\nRead the remaining-round count from `counter.txt`. If the file doesn't exist or the count ≤ 0, print \"rounds exhausted\" and stop.\n\nLoop:\n\n```\nwhile coun... | f2 | {
"dispatcher": [
"f1"
],
"coder": [
"f5",
"f7",
"f3"
],
"reviewer": [
"f5",
"f4",
"f6",
"f3"
]
} | I need you to set up a 3-agent pipeline for bug bounty: dispatcher, coder, and reviewer.
- **dispatcher** orchestrates: calls coder, extracts the report file path from coder's reply, then calls reviewer on that path, decrements a counter, and loops. Does no analysis itself.
- **coder** explores the codebase, picks an ... | I need you to set up a 3-agent pipeline for bug bounty: dispatcher, coder, and reviewer.
- **dispatcher** orchestrates: calls coder, extracts the report file path from coder's reply, then calls reviewer on that path, decrements a counter, and loops. Does no analysis itself.
- **coder** explores the codebase, picks an ... |
pg_002__seed_42 | pg_002 | 42 | [
"dispatcher",
"coder",
"reviewer"
] | [
{
"id": "f1",
"text": "This project has been running stably for many years — any obvious fatal bug would have killed it long ago. So:\n\n- Don't report problems that are obvious at a glance (e.g. \"some map is never erased\") — if it were that obvious, the project team would have fixed it themselves\n- Trul... | f5 | {
"dispatcher": [
"f2"
],
"coder": [
"f6",
"f1",
"f7"
],
"reviewer": [
"f6",
"f4",
"f3",
"f7"
]
} | I need you to set up a 3-agent pipeline for bug bounty: dispatcher, coder, and reviewer.
- **dispatcher** orchestrates: calls coder, extracts the report file path from coder's reply, then calls reviewer on that path, decrements a counter, and loops. Does no analysis itself.
- **coder** explores the codebase, picks an ... | I need you to set up a 3-agent pipeline for bug bounty: dispatcher, coder, and reviewer.
- **dispatcher** orchestrates: calls coder, extracts the report file path from coder's reply, then calls reviewer on that path, decrements a counter, and loops. Does no analysis itself.
- **coder** explores the codebase, picks an ... |
pg_003__seed_1 | pg_003 | 1 | [
"dispatcher",
"coder",
"reviewer"
] | [
{
"id": "f1",
"text": "When you finish, briefly report to the dispatcher what you did.",
"is_distractor": false
},
{
"id": "f2",
"text": "Each round, before calling the coder, read ideas.xml and select which idea the coder should work on:\n\n1. Every idea carries an `attempts` count and a re... | f7 | {
"dispatcher": [
"f5",
"f2"
],
"coder": [
"f6",
"f8",
"f3",
"f1"
],
"reviewer": [
"f6",
"f9",
"f4",
"f1"
]
} | I need you to set up a 3-agent pipeline for bug bounty: dispatcher, coder, and reviewer.
- **dispatcher** orchestrates: each round it selects which idea to pursue next, calls the coder on that idea, extracts the report file path from the coder's reply, then calls the reviewer on that path, decrements a counter, and lo... | I need you to set up a 3-agent pipeline for bug bounty: dispatcher, coder, and reviewer.
- **dispatcher** orchestrates: each round it selects which idea to pursue next, calls the coder on that idea, extracts the report file path from the coder's reply, then calls the reviewer on that path, decrements a counter, and lo... |
pg_003__seed_42 | pg_003 | 42 | [
"dispatcher",
"coder",
"reviewer"
] | [
{
"id": "f1",
"text": "You drive the explore → write → review → improve loop: each round, select the next idea, then alternate calls to the coder and reviewer agents.\n\nRead the remaining-round count from `counter.txt`. If the file doesn't exist or the count ≤ 0, print \"rounds exhausted\" and stop.\n\nLoo... | f5 | {
"dispatcher": [
"f1",
"f2"
],
"coder": [
"f8",
"f9",
"f3",
"f7"
],
"reviewer": [
"f8",
"f6",
"f4",
"f7"
]
} | I need you to set up a 3-agent pipeline for bug bounty: dispatcher, coder, and reviewer.
- **dispatcher** orchestrates: each round it selects which idea to pursue next, calls the coder on that idea, extracts the report file path from the coder's reply, then calls the reviewer on that path, decrements a counter, and lo... | I need you to set up a 3-agent pipeline for bug bounty: dispatcher, coder, and reviewer.
- **dispatcher** orchestrates: each round it selects which idea to pursue next, calls the coder on that idea, extracts the report file path from the coder's reply, then calls the reviewer on that path, decrements a counter, and lo... |
pg_004__seed_1 | pg_004 | 1 | [
"dispatcher",
"plan-creator",
"plan-critic",
"coder",
"code-critic"
] | [
{
"id": "f1",
"text": "Keep `SOLUTION.md` lean. Its body — everything except the `<review>` block — must stay under 3000 words (~20KB), about a four-page note; record only the final state and move iteration-by-iteration history into a separate `CHANGELOG.md`. Bold text must not exceed 5% of the file: if eve... | f7 | {
"dispatcher": [
"f2"
],
"plan-creator": [
"f3",
"f10",
"f9",
"f5"
],
"plan-critic": [
"f3",
"f4",
"f8",
"f5"
],
"coder": [
"f3",
"f12",
"f6",
"f1"
],
"code-critic": [
"f3",
"f11",
"f8"
]
} | I need you to set up a 5-agent pipeline that solves mathematical optimization problems. A problem arrives as a natural-language statement in `problem.md`, and the pipeline turns it into a vetted plan and then working, verified solver code.
The five agents:
- **dispatcher** orchestrates the run: it drives the plan loo... | I need you to set up a 5-agent pipeline that solves mathematical optimization problems. A problem arrives as a natural-language statement in `problem.md`, and the pipeline turns it into a vetted plan and then working, verified solver code.
The five agents:
- **dispatcher** orchestrates the run: it drives the plan loo... |
pg_004__seed_42 | pg_004 | 42 | [
"dispatcher",
"plan-creator",
"plan-critic",
"coder",
"code-critic"
] | [{"id":"f1","text":"Keep `SOLUTION.md` lean. Its body — everything except the `<review>` block —(...TRUNCATED) | f8 | {"dispatcher":["f7"],"plan-creator":["f10","f11","f9","f2"],"plan-critic":["f10","f4","f12","f2"],"c(...TRUNCATED) | "I need you to set up a 5-agent pipeline that solves mathematical optimization problems. A problem a(...TRUNCATED) | "I need you to set up a 5-agent pipeline that solves mathematical optimization problems. A problem a(...TRUNCATED) |
Dataset Card for PerspectiveGap
PerspectiveGap is a benchmark for evaluating LLMs' ability to compose orchestration prompts for multi-agent systems. It tests whether a model can decide what each sub-agent in a multi-agent workflow needs to know, without leaking irrelevant context.
Paper: PerspectiveGap: A Benchmark for Multi-Agent Orchestration Prompting
Code and scorers: WhymustIhaveaname/PerspectiveGap
Interactive leaderboard: sun1245/PerspectiveGap-Leaderboard
Project collection: PerspectiveGap Benchmark
This Hugging Face dataset contains the released rendered set: 220 rows from 110 scenarios rendered with seeds 1 and 42. Each row includes the two task prompts, visible fragments, distractor ID, and answer key.
Dataset Details
The dataset is released as a single test split. It is intended for benchmarking prompt composition and context filtering in multi-agent orchestration settings.
Dataset Sources
The released JSONL is deterministically rendered from the source scenarios in the GitHub repository. Three generic prompt-engineering distractor fragments are included in the source repository with source URLs recorded in their markdown frontmatter; preserve those attributions if you redistribute modified source files.
Uses
Direct Use
Use PerspectiveGap to evaluate models or prompting systems on two tasks:
- Role-fragment assignment: select the visible fragment IDs that belong in each sub-agent prompt.
- Prompt writing: write one prompt per sub-agent while including only the needed fragments.
The accompanying GitHub repository contains scripts for rendering model requests and scoring predictions.
Out-of-Scope Use
Do not use this test set, including reference_need_sets or distractor_id, as model training data or as an in-context demonstration set when reporting benchmark results. The dataset is not designed to represent all possible multi-agent architectures, application domains, or safety requirements.
Dataset Structure
Data Splits
| split | rows | scenarios | shuffle seeds |
|---|---|---|---|
test |
220 | 110 | 1, 42 |
Data Fields
| field | meaning |
|---|---|
evaluation_id |
stable row ID |
scenario_id |
source scenario ID |
shuffle_seed |
seed used for distractor sampling and fragment order |
roles |
roles that need prompts |
fragments |
visible fragments shown to the model |
distractor_id |
visible fragment ID of the distractor |
reference_need_sets |
answer key in visible fragment IDs |
role_assignment_prompt |
prompt for the JSON assignment task |
prompt_writing_prompt |
prompt for the free-form writing task |
distractor_id is already in the visible ID space, so no relabel map is needed.
Each dataset row contains both task prompts. The reference runner in the GitHub repository sends one model request per selected task.
Loading
from datasets import load_dataset
ds = load_dataset("sun1245/PerspectiveGap", split="test")
print(ds[0]["evaluation_id"])
If you mirror this dataset under another namespace, replace sun1245/PerspectiveGap with that dataset repository ID.
Evaluation
git clone https://github.com/WhymustIhaveaname/PerspectiveGap.git
cd PerspectiveGap
uv sync
# Score the bundled example without any API key.
uv run python scripts/score_predictions.py --predictions tests/fixtures/example_predictions.jsonl
To run a model, set the relevant provider API key and use scripts/run_model_predictions.py; see the GitHub README for provider names and environment variables.
Dataset Creation
The benchmark scenarios were curated to test information routing decisions in multi-agent workflows. For the released Hugging Face file, each source scenario is rendered with two deterministic shuffle seeds. Rendering injects one generic distractor fragment, shuffles the visible fragments, relabels them into the visible f1, f2, ... ID space, and emits both task prompts plus the answer key.
Evaluation Notes
- PerspectiveGap is an answer-keyed benchmark for multi-agent orchestration prompting and context routing.
- The released scenarios are curated to stress role-specific information selection, distractor resistance, and prompt composition across diverse orchestration topologies.
- The included answer keys make scoring transparent and auditable.
- The prompt-writing scorer in the GitHub repository is deterministic, fast, and reproducible; it measures whether generated prompts include the needed fragments while excluding irrelevant ones.
- For benchmark reporting, use the dataset as a held-out evaluation set and follow the rendering and scoring scripts in the GitHub repository.
More Information
- GitHub repository: https://github.com/WhymustIhaveaname/PerspectiveGap
- arXiv paper: https://arxiv.org/abs/2606.08878
- Interactive leaderboard: https://huggingface.co/spaces/sun1245/PerspectiveGap-Leaderboard
- Hugging Face collection: https://huggingface.co/collections/sun1245/perspectivegap-benchmark-6a29cc320b94890356c60dd7
Citation
@misc{sun2026perspectivegapbenchmarkmultiagentorchestration,
title={PerspectiveGap: A Benchmark for Multi-Agent Orchestration Prompting},
author={Youran Sun and Xingyu Ren and Kejia Zhang and Xinpeng Liu and Jiaxuan Guo},
year={2026},
eprint={2606.08878},
archivePrefix={arXiv},
primaryClass={cs.CL},
url={https://arxiv.org/abs/2606.08878},
}
- Downloads last month
- -