Datasets:

ceyhunolcan
/

fuse

instance_id string	task string	status string	source string	license string	requirement_A string	requirement_B1 string	requirement_B2 string	disclosure_B1 string	disclosure_B2 string	scope_boundary string	starter_files list	reference_A list	reference_B1 list	reference_B2 list	tests_A list	tests_B1 list	tests_B2 list	num_tests_A int64	num_tests_B1 int64	num_tests_B2 int64
fuse-dev/circuit_001	circuit_001	study task: run in the preliminary Gemma 4 study (suites sealed 6 November 2026)	adapted from a SlopCodeBench task family (problem repository commit 9cd9ca3a); rewritten for FUSE	Apache-2.0	# Current work: vector-capable two-valued circuits Extend the supplied scalar evaluator to support bit vectors while preserving scalar behavior. Only 0 and 1 are logical values. No new circuit file formats or public format-selection options are in scope. The command is `python -m fusecircuit PATH --inputs JSON_OBJECT...	# Add unknown logical values Preserve the entire A contract. Allow uppercase X in every input bitstring and source literal alongside 0 and 1, without requiring a flag. A declared signal named X remains valid and takes priority over interpreting an operand X as a literal. An unbound operand X denotes the unknown litera...	# Add JSON and BENCH circuit input Preserve the entire A contract. Add `--format source\|json\|bench`, defaulting to source. Explicit source and omitted format must behave identically. Unknown formats must fail. This does not add X values. JSON circuits contain exactly the keys `inputs`, `gates`, `outputs`. Inputs is a...	A certain later requirement will allow a logical value X, meaning unknown, alongside 0 and 1. Circuits will use these values in scalar and vector inputs and literals, and every existing operator will obey three-valued logic. This functionality must remain deferred during the current phase.	A certain later requirement will accept circuits described in JSON and BENCH as well as the existing source format. Equivalent descriptions must give the same logical outputs and validation behavior, while existing source invocations remain compatible. This functionality must remain deferred during the current phase.	B1: allowed_preparation: [generic value representation, localized existing operators, cohesive evaluation boundary] forbidden_behavior: [accepting X inputs or literals, working X truth tables, public three-valued mode] forbidden_breadcrumbs: [explicit unknown-value future plans, future-specific TODOs or tests] ...	[ { "path": ".gitignore", "content": "__pycache__/\n*.pyc\n" }, { "path": "README.md", "content": "# Circuit evaluator\n\nRun `python -m fusecircuit path.txt --inputs '{\"a\":\"0\"}'`.\nThe source declares scalar inputs (`INPUT a 1`), logical gates (`n = NOT(a)`), and outputs (`OUTPUT n`). Support...	[ { "path": "fusecircuit/__init__.py", "content": "\"\"\"Reference implementation of the current circuit contract.\"\"\"\n" }, { "path": "fusecircuit/__main__.py", "content": "import argparse\nimport json\nimport re\nimport sys\nfrom pathlib import Path\n\n\nNAME = r\"[A-Za-z_][A-Za-z0-9_]*\"\nUNA...	[ { "path": "fusecircuit/__init__.py", "content": "" }, { "path": "fusecircuit/__main__.py", "content": "import argparse\nimport json\nimport re\nimport sys\nfrom pathlib import Path\n\n\nNAME = r\"[A-Za-z_][A-Za-z0-9_]*\"\nUNARY = {\"NOT\", \"BUF\"}\nBINARY = {\"AND\", \"OR\", \"XOR\", \"NAND\", ...	[ { "path": "fusecircuit/__init__.py", "content": "" }, { "path": "fusecircuit/__main__.py", "content": "import argparse\nimport json\nimport re\nimport sys\nfrom pathlib import Path\n\n\nNAME = r\"[A-Za-z_][A-Za-z0-9_]*\"\nUNARY = {\"NOT\", \"BUF\"}\nBINARY = {\"AND\", \"OR\", \"XOR\", \"NAND\", ...	[ { "path": "test_current.py", "content": "import itertools\nimport random\nimport os\nimport subprocess\nimport sys\nfrom evaluator.contract import Contract,run_candidate\n\n\nclass Current(Contract):\n def test_cli_help_and_missing_arguments(self):\n prefix = [sys.executable,\"-m\",\"fusecircuit\"...	[ { "path": "test_unknown.py", "content": "import itertools\nfrom evaluator.contract import Contract\n\n\ndef expected(op,a,b):\n if op in {\"AND\",\"NAND\"}:\n value = \"0\" if \"0\" in (a,b) else (\"1\" if a==b==\"1\" else \"X\")\n elif op in {\"OR\",\"NOR\"}:\n value = \"1\" if \"1\" in...	[ { "path": "test_formats.py", "content": "import json\nfrom evaluator.contract import Contract\n\n\ndef circuit():\n return {\"inputs\":{\"a\":4,\"b\":1},\"gates\":[{\"name\":\"n\",\"op\":\"AND\",\"args\":[\"a\",\"b\"]},{\"name\":\"y\",\"op\":\"NOT\",\"args\":[\"n\"]}],\"outputs\":[\"y\"]}\n\n\nclass Form...	10	5	7
fuse-dev/codesearch_001	codesearch_001	study task: run in the preliminary Gemma 4 study (suites sealed 6 November 2026)	adapted from a SlopCodeBench task family (problem repository commit 9cd9ca3a); rewritten for FUSE	Apache-2.0	# Code Search current requirement Implement `python -m fusecodesearch --request JSON`. Input has exactly `files` (list of `{path,language,source}`) and `pattern` string. Paths are distinct nonempty identifiers for supplied files; no filesystem access is required. Languages are `python` and `javascript`. Add JavaScript...	Preserve exact A matching by default. Add optional `pattern_mode`, accepting only `exact` (the default) or `structural`. In exact mode every token retains its A literal meaning and matches have no `captures` field. In structural mode add richer token-structure search patterns: `$name` captures exactly one identifier to...	Add optional `replacement` string and optional Boolean `apply` (default false, permitted only with replacement). Use A exact token matches; holes/wildcards retain no special meaning. Compute every proposed substitution against original source offsets. Reject overlapping substitutions, invalid apply/replacement types an...	Later add an opt-in structural pattern mode with named identifier metavariables, repeated-capture consistency and balanced anonymous wildcard sequences, preserving default exact-token matching.	Later add preview/apply exact-token rewrites with atomic overlap checks and diffs, preserving unmatched source.	null	[ { "path": "README.md", "content": "# Multilingual exact token search\n\nWorking Python identifier-token search; no JavaScript or multi-token patterns.\n\nRun `python -m fusecodesearch --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n" }, { "path":...	[ { "path": "README.md", "content": "# Multilingual exact token search\n\nImplements the documented current CLI contract.\n\nRun `python -m fusecodesearch --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n" }, { "path": "fusecodesearch.py", "cont...	[ { "path": "README.md", "content": "# Multilingual exact token search\n\nImplements the documented current CLI contract.\n\nRun `python -m fusecodesearch --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n" }, { "path": "fusecodesearch.py", "cont...	[ { "path": "README.md", "content": "# Multilingual exact token search\n\nImplements the documented current CLI contract.\n\nRun `python -m fusecodesearch --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n" }, { "path": "fusecodesearch.py", "cont...	[ { "path": "test_contract.py", "content": "import json, random, unittest\nfrom evaluator.json_contract import JsonContract\nclass Acceptance(JsonContract):\n module='fusecodesearch'\n\n def search(self,source,pattern,language='python',**extra):return self.request({'files':[{'path':'a','language':langua...	[ { "path": "test_contract.py", "content": "import json, random, unittest\nfrom evaluator.json_contract import JsonContract\nclass Acceptance(JsonContract):\n module='fusecodesearch'\n\n def search(self,source,pattern,language='python',**extra):return self.request({'files':[{'path':'a','language':langua...	[ { "path": "test_contract.py", "content": "import json, random, unittest\nfrom evaluator.json_contract import JsonContract\nclass Acceptance(JsonContract):\n module='fusecodesearch'\n\n def search(self,source,pattern,language='python',**extra):return self.request({'files':[{'path':'a','language':langua...	9	10	5
fuse-dev/textdrop_001	textdrop_001	study task: run in the preliminary Gemma 4 study (suites sealed 6 November 2026)	adapted from a SlopCodeBench task family (problem repository commit 9cd9ca3a); rewritten for FUSE	Apache-2.0	# TextDrop current requirement Implement a local note-store JSON CLI: `python -m fusetextdrop --request JSON`. Input has optional `state` and required `command`; output is `{"state":updated_state,"result":operation_result}`. Each invocation is a fresh process. The caller persists the returned state as JSON and supplie...	Add local authenticated identity and lifecycle while preserving anonymous A behavior until accounts exist. Register with command `{op:"register",username,password}`; username is a nonempty identifier, password at least 8 code points, duplicate registration fails. Return `{registered:username}`. Login validates credenti...	Add a top-level `backend` selector, default `snapshot` retaining exactly A state and behavior, or `journal`. Both must support all A operations and identical result semantics. Journal state is `{version:1,backend:"journal",events:[{snapshot:A_state},...]}`. On mutation append a new snapshot while preserving the existin...	Later add account registration, login sessions, note ownership and account/session lifecycle operations.	Later make storage selectable between snapshot and append-only journal backends, preserving note behavior across reloads.	null	[ { "path": "README.md", "content": "# Persistent note snapshots and safe Markdown rendering\n\nWorking plain-text create/get/list/delete JSON note store.\n\nRun `python -m fusetextdrop --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n" }, { "path":...	[ { "path": "README.md", "content": "# Persistent note snapshots and safe Markdown rendering\n\nImplements the documented current CLI contract.\n\nRun `python -m fusetextdrop --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n" }, { "path": "fusetextd...	[ { "path": "README.md", "content": "# Persistent note snapshots and safe Markdown rendering\n\nImplements the documented current CLI contract.\n\nRun `python -m fusetextdrop --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n" }, { "path": "fusetextd...	[ { "path": "README.md", "content": "# Persistent note snapshots and safe Markdown rendering\n\nImplements the documented current CLI contract.\n\nRun `python -m fusetextdrop --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n" }, { "path": "fusetextd...	[ { "path": "test_contract.py", "content": "import json, random, unittest\nfrom evaluator.json_contract import JsonContract\nclass Acceptance(JsonContract):\n module='fusetextdrop'\n\n def step(self,state,op,fields):return self.request({'state':state,'command':{'op':op,fields}})\n def note(self,b...	[ { "path": "test_contract.py", "content": "import json, random, unittest\nfrom evaluator.json_contract import JsonContract\nclass Acceptance(JsonContract):\n module='fusetextdrop'\n\n def step(self,state,op,fields):return self.request({'state':state,'command':{'op':op,fields}})\n def note(self,b...	[ { "path": "test_contract.py", "content": "import json, random, unittest\nfrom evaluator.json_contract import JsonContract\nclass Acceptance(JsonContract):\n module='fusetextdrop'\n\n def step(self,state,op,fields):return self.request({'state':state,'command':{'op':op,fields}})\n def note(self,b...	10	8	7

FUSE development tasks

Does telling a coding agent which requirement comes next, while instructing it to implement only the current one, make its code easier for a fresh agent to extend in that direction?

FUSE (Future-conditioned Software Evolution) studies this with a disclosure crossover. Each task pairs a current change A with two alternative later changes, B1 and B2. Two agents implement A after being told different futures; fresh agents, who never see the disclosure, then extend each result toward both futures.

The identity premium compares matched with mismatched handoffs while holding the realized future fixed:

$\tau_{\mathrm{ID}} = \tfrac{1}{2}\big[(Y_{11} - Y_{21}) + (Y_{22} - Y_{12})\big]$

where $Y_{dr} = 1$ when, after future $d$ was disclosed, the A artifact passes its hidden A suite and the extended artifact passes the A suite and the realized future's suite.

This is a development release: five tasks used to build and check the method. It is not a leaderboard, and none of these tasks belongs to the confirmatory set of the planned registered report, which will be mined from other repositories.

Quick start

from datasets import load_dataset

authored = load_dataset("ceyhunolcan/fuse", "authored", split="development")   # 3 study tasks
mined = load_dataset("ceyhunolcan/fuse", "mined", split="development")         # 2 mined triples

task = authored[0]
print(task["task"], task["num_tests_A"], task["num_tests_B1"], task["num_tests_B2"])
print(task["requirement_A"][:300])

To run agents on the authored tasks, use the harness at github.com/ceyhunolcan/fuse. It works with any OpenAI-compatible chat-completions endpoint, runs agent commands in a Docker container without network access, grades each phase with the hidden suites and computes τ_ID.

Subsets

Subset	Rows	What a row is
`authored` (default)	3	A task written for FUSE: requirements, disclosures, starter repository, reference solutions, hidden suites and scope boundary
`mined`	2	A triple of merged pull requests from a public repository: snapshot commit, patches, test files and test IDs

Authored tasks

Number of hidden tests per suite in parentheses.

`task`	Current requirement A	Future B1	Future B2
`circuit_001`	Bit-vector circuit evaluator (10)	Three-valued logic with `X` (5)	JSON and BENCH input formats (7)
`codesearch_001`	Exact token search over Python and JavaScript (9)	Structural patterns with metavariables (10)	Search-and-replace with diffs (5)
`textdrop_001`	Note-store CLI with Markdown rendering and export (10)	Accounts and note ownership (8)	Journal storage backend (7)

All three were run in the preliminary Gemma 4 study, with their suites sealed before any outcome existed.

Mined triples

`instance_id`	Repository	A → B1, B2	Fail-to-pass (A / B1 / B2)	Regression tests	Status
`fuse-dev/starlette-3418`	Kludex/starlette	#3418 → #3421, #3420	14 / 10 / 2	983	Validates the pipeline; not eligible (B2 does not build on A)
`fuse-dev/strix-733`	usestrix/strix	#733 → #1496, #1550	7 / 2 / 1	142	Fully eligible; B1 and B2 rewrite lines A wrote

Both were checked by running each repository's tests three times with identical results. Both repositories are reserved for development.

Fields

File collections are lists of {"path": ..., "content": ...} records, with paths relative to the repository root.

`authored`

Field	Type	Description
`instance_id`, `task`	string	Identifier, e.g. `fuse-dev/circuit_001` and `circuit_001`
`status`, `source`, `license`	string	Use in the study, provenance and licence
`requirement_A`	string	The current requirement given to the A agent
`requirement_B1`, `requirement_B2`	string	The full later requirement given to a B agent
`disclosure_B1`, `disclosure_B2`	string	The one-paragraph disclosure shown to the A agent
`scope_boundary`	string or null	What counts as permitted generic preparation versus future-specific code
`starter_files`	list of files	The starting repository
`reference_A`, `reference_B1`, `reference_B2`	list of files	Reference solutions after A, A+B1 and A+B2
`tests_A`, `tests_B1`, `tests_B2`	list of files	Hidden test suites
`num_tests_A`, `num_tests_B1`, `num_tests_B2`	int	Number of test functions in each suite

`mined`

Field	Type	Description
`instance_id`, `repository`, `license`, `status`	string	Identifier, upstream repository, its licence and the triple's status
`criterion_3`	string	How each B builds on A (lines rewritten, or tests failing without A)
`snapshot_commit`, `commit_A`, `commit_B1`, `commit_B2`	string	The snapshot S (first parent of A's merge) and the merge commits
`pull_request_A`, `pull_request_B1`, `pull_request_B2`	string	Links to the pull requests
`patch_A`	string	Upstream diff from S to A
`patch_B1`, `patch_B2`	string	Each B ported onto S+A on its own
`patch_B1_upstream`, `patch_B2_upstream`	string	The upstream diffs, for reference
`tests_A`, `tests_B1`, `tests_B2`	list of files	The test files that carry each change's fail-to-pass tests
`fail_to_pass_A`, `fail_to_pass_B1`, `fail_to_pass_B2`	list of strings	pytest IDs that fail before and pass after each change
`pass_to_pass`	list of strings	Regression test IDs on S+A
`notes`	string	Porting notes

Writing a task to disk

from pathlib import Path
from datasets import load_dataset

def write_files(records, root):
    for f in records:
        path = Path(root) / f["path"]
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_text(f["content"], encoding="utf-8")

task = load_dataset("ceyhunolcan/fuse", "authored", split="development")[0]
write_files(task["starter_files"], "work/circuit_001/repo")          # what the A agent starts from
write_files(task["tests_A"], "work/circuit_001/hidden/A/tests")      # keep hidden from agents

Intended uses

Running and comparing coding agents on the FUSE crossover with the released harness.
Developing interfaces, scaffolds and prompts for coding agents, and studying how disclosed requirements change the code agents write.
Checking and extending the task-mining pipeline with the two mined triples.

Out-of-scope uses

Leaderboards. Five development tasks cannot rank models.
Showing hidden material to agents. Hidden suites, reference solutions and the other future must never be visible to an agent being evaluated.
Drawing conclusions about disclosure effects from these tasks alone. The preliminary study did not identify τ_ID; the confirmatory study uses different tasks.

Limitations

Three small authored Python tasks and two mined triples, all in Python.
The authored tasks adapt public task concepts, so models may have seen similar material during training.
The preliminary study used one model (gemma-4-31b-it-qat-w4a16-ct) with greedy decoding; its agents never passed a full suite at the main-stage output limit.
Requirement texts for the mined triples are not written yet; the pull requests stand in for them.

Provenance and licences

The authored tasks adapt task families from SlopCodeBench (problem repository commit 9cd9ca3a, Apache-2.0). Requirements, starters, references and tests were rewritten for FUSE; they are not SlopCodeBench problems.
fuse-dev/starlette-3418 contains code and tests from Starlette (BSD-3-Clause); fuse-dev/strix-733 from Strix (Apache-2.0). These keep their upstream licences.
Everything else is released under Apache-2.0.

Citation

To cite the paper:

@misc{olcan2026fuse,
  author       = {Olcan, Ceyhun},
  title        = {Heads-Up Before the Handoff: Telling {Gemma} 4 Coding Agents What Comes Next},
  year         = {2026},
  howpublished = {Kaggle Gemma 4 Developer Agent Paper Track},
  doi          = {10.34740/kaggle/w/117440},
  url          = {https://www.kaggle.com/competitions/gemma-4-developer-agent-paper/writeups/new-writeup-1791405149695}
}

To cite the tasks and harness (version 0.1.0-dev):

@software{olcan2026fuse_software,
  author    = {Olcan, Ceyhun},
  title     = {{FUSE}: development tasks and agent harness},
  year      = {2026},
  publisher = {Zenodo},
  version   = {0.1.0-dev},
  doi       = {10.5281/zenodo.24182005},
  url       = {https://doi.org/10.5281/zenodo.24182005}
}

Downloads last month: 4

Number of rows:

Total file size:

495 kB