README.md

metadata

license: mit
language:
  - en
task_categories:
  - text-generation
pretty_name: PrototypeBench v0.1
tags:
  - benchmark
  - llm-evaluation
  - llm-benchmark
  - coding-agent
  - agent-evaluation
  - swe-bench
  - fastapi
  - python
  - software-engineering
  - execution-based-evaluation
  - rlvr
size_categories:
  - n<1K
source_datasets:
  - original
configs:
  - config_name: default
    data_files:
      - split: test
        path: instances.jsonl
dataset_info:
  features:
    - name: instance_id
      dtype: string
    - name: repo
      dtype: string
    - name: pr_number
      dtype: int32
    - name: pr_url
      dtype: string
    - name: pr_title
      dtype: string
    - name: base_commit
      dtype: string
    - name: head_commit
      dtype: string
    - name: problem_statement
      dtype: string
    - name: patch
      dtype: string
    - name: test_patch
      dtype: string
    - name: stack_domain
      dtype: string
    - name: contamination_tier
      dtype: string
    - name: created_at
      dtype: string
    - name: schema_version
      dtype: string

PrototypeBench v0.1

Can your agent ship a full-stack AI-native prototype?

PrototypeBench is an open benchmark for evaluating AI coding agents on full-stack feature shipping. Where SWE-Bench measures bug-fixing in mature Python libraries, PrototypeBench measures "can the agent ship a full-stack feature on a modern AI-native stack?"

• Project home: https://github.com/prototypebench/prototypebench
• Website: https://prototypebench.org
• License: MIT
• Version: v0.1 (initial corpus)
• Language: English (problem statements), Python (backend code), TypeScript/JavaScript (frontend code, future)

Dataset Summary

123 PR-mined task instances from active open-source repositories, each shaped for SWE-Bench-compatible execution-based scoring:

Stat	Value
Total instances	123
Sources	3 (fastapi/full-stack-fastapi-template, IBM/mcp-context-forge, usebruno/bruno)
FAIL_TO_PASS tests	940
PASS_TO_PASS regression-guard tests	31,945
Total test cases per full eval	32,885
stack_domain	71 backend_only + 52 frontend_only (fullstack instances in later versions)
contamination_tier	123 held_out (all post-2026-01-01)
Schema version	0.1

Comparison: SWE-Bench Verified has 500 instances, SWE-Bench Lite 300, HumanEval 164. v1 public-beta targets 200–300.

Scoring

Execution-based binary scoring (no LLM-as-judge):

score(instance) = 1  iff  FAIL_TO_PASS ⊆ passing_tests
                     AND  PASS_TO_PASS ⊆ passing_tests    (no regression)
                  0  otherwise

Judge: pytest (backend) and Playwright (frontend, future). Ground truth = the actual merged PR diff (hidden from the agent). See the methodology notes.

Usage

from datasets import load_dataset

ds = load_dataset("banyaaiofficial/prototypebench-v1", split="test")

for item in ds:
    print(item["instance_id"])           # e.g. "IBM__mcp-context-forge-4270"
    print(item["problem_statement"])     # NL task spec (PR body or closing issue)
    base_sha = item["base_commit"]        # pre-PR commit — agent starts here
    # Agent produces a non-test unified diff against base_sha.
    # Score it with the companion harness:
    #   pbench score --source <short> --pr <N> --patch-file agent_patch.diff

Each instance extends the SWE-Bench instances.jsonl schema with dual-test fields (fail_to_pass.backend / .frontend, test_patch_backend / .frontend) for future Playwright integration.

Full schema: https://github.com/prototypebench/prototypebench/blob/main/schemas/task_instance.schema.json

Source Composition

Source	Stars	License	Instances	F2P	P2P	Stack
fastapi/full-stack-fastapi-template	42.7k	MIT	3	7	77	backend_only
IBM/mcp-context-forge	3.6k	Apache-2	68	682	31,567	backend_only
usebruno/bruno	44k	MIT	52	251	301	frontend_only (NEW v0.2)

All PRs are merged PRs with maintainer-reviewed tests. Task instances mine the natural atomic unit of change (one feature or fix at a time).

bruno frontend instances are validated end-to-end via a Playwright + Electron runner (harness/frontend_direct_runner.py) — docker run of a custom prototypebench/playwright-electron image (Playwright base + GTK/NSS/ATK/Xvfb + chrome-sandbox SUID) that hosts bruno's own webServer config in-process. No external backend dependency.

Data Fields

See the task-schema doc for full field-by-field semantics. Highlights:

• instance_id — stable unique ID (owner__repo-<pr_number>)
• base_commit / head_commit — SHAs bounding the reference change
• problem_statement — natural-language task spec (from closing issue body, else PR description)
• patch — reference solution (non-test diff). Hidden from the agent at evaluation time.
• test_patch — test-only diff that the harness applies before running the agent's patch
• fail_to_pass — {backend: [...], frontend: [...]} — tests the agent must make pass
• pass_to_pass — {backend: [...], frontend: [...]} — regression-guard tests (must not break)
• stack_domain — backend_only | frontend_only | fullstack
• environment — python_version, node_version, uv_lock_sha, etc. for reproducible builds
• contamination_tier — public | held_out | internal_only

Contamination & Fairness

• Held-out by construction: all v0.2 instances are merged after 2026-01-01 (Claude Opus 4.7 cutoff). Submitters must disclose their model cutoff for point-count adjustment.
• Rotation: held-out tier is rotated per leaderboard season (Phase 5).
• No vendor branding: benchmark carries no vendor name. Hosted on banyaaiofficial for convenience only; the benchmark is project-neutral.

Limitations

• v0.2 adds frontend coverage but no fullstack instances yet (single PR touching both backend and frontend in a coordinated way — pending source diversification).
• Two backend sources cover 71 instances; bruno covers 52 frontend instances — single-source frontend pool is the current trade-off (see PLAN.md §3.3.1-3.3.2 for the OSS-landscape diagnosis behind it).
• "test strength = benchmark quality": PRs with weak tests are filtered but not perfectly. Curator review recommended.
• Execution-based scoring requires running tests (not instantaneous) — see the harness for Docker-based reproducible runs.
• bruno frontend instances run inside an Electron-capable Playwright image with Xvfb; cold-start (npm run setup + workspace builds) adds ~3-5 min per phase. Caching across base and head phases via Docker named volumes is a v0.3 target.

Related Benchmarks

• SWE-Bench — Python library bug-fixes (2,294 instances). PrototypeBench extends the pattern to modern AI-native full-stack apps.
• SWE-Bench Lite / Verified — curated subsets.
• Terminal-Bench — CLI tasks.
• BigCodeBench — library-usage function-level tasks.

Citation

Citation format will be fixed at Phase 4 public launch. For now:

@misc{prototypebench_v02,
  title        = {PrototypeBench v0.2: An AI-native Full-Stack Coding Agent Benchmark},
  year         = {2026},
  url          = {https://github.com/prototypebench/prototypebench},
  note         = {123 instances across 3 source repos (71 backend + 52 frontend);
                  execution-based scoring (pytest + Playwright)}
}

Changelog

• v0.2.2 (2026-05-24): fix — Playwright snapshot tests (tests/snapshots/**) on the bruno source are now P2P-only advisory. They're kept in F2P (where they're often the actual feature test — e.g. #7948's "transient request quit flow" is checked via snapshot specs) but excluded from P2P (where they cause spurious failures from rendering / timing drift between base and score-time, even with byte-identical patches). Verified bruno#7948 with byte-identical agent_patch: previously F2P 4/4 + P2P 13/14 = score 0; now F2P 4/4 + P2P 0/0 = score 1. Total P2P across 52 bruno instances: 327 → 301 (26 snapshot tests dropped). Schema unchanged.
• v0.2.1 (2026-05-24): fix — bruno frontend instances rebuilt with the corrected test_patch_frontend extraction. Earlier v0.2 captured only tests/**/*.spec.ts (Playwright specs), missing the co-located fixtures (.bru collections, init-user-data/preferences.json). Result: even a byte-identical copy of the reference patch could fail at score time because specs couldn't load their fixtures. Re-verified on bruno#7947: F2P 0/12 → 11/12 with a byte-identical agent_patch (the remaining 1/12 is a Playwright flake unrelated to the fix). Source extraction now uses tests/** (entire test subtree). Instance count unchanged (52 frontend). See docs/phase3-fe-smoke-analysis.md for the diagnostic trail.
• v0.2 (2026-05-23): +52 frontend_only instances from usebruno/bruno via the new playwright_direct runner (custom Playwright+Electron image with Xvfb). Corpus 71 → 123. F2P 689 → 940, P2P 31,644 → 31,971. Frontend ratio 0% → 42%. Schema v0.1 unchanged.
• v0.1 (2026-04-20): initial corpus. 71 backend_only instances, all held_out. Schema v0.1.