hl3372/arc-agi-task-bank

ARC Task Bank

17,470 verified tasks in the ARC-AGI format, written by an LLM task generator, each with the full record of how it was designed and checked. The bank accompanies our ARC Prize paper (citation below).

Tasks	17,470, committed between 2026-07-31 and 2026-10-28
Pipeline versions	final pipeline ("v1", from 2026-10-01): 14,796 tasks; earlier versions: 2,674
Design records	98,770 unique model calls (97,047 with their parsed response) and 17,470 task lifecycle records
Teacher difficulty	DeepSeek V4.1 Flash 1017 solve rate for 17,468 tasks (median 4 draws)
Duplicates	no exact or recoloured duplicates

from datasets import load_dataset

tasks = load_dataset("<org>/<repo>", "tasks", split="train")          # one row per task (~50 MB)
records = load_dataset("<org>/<repo>", "records", split="train")      # every model call + lifecycle (~420 MB)

# only the lifecycle records, or only the model calls
life = load_dataset("<org>/<repo>", data_files="data/records/lifecycle-*.parquet", split="train")
calls = load_dataset("<org>/<repo>", data_files="data/records/calls-*.parquet", split="train")

arc/arc_tasks.zip holds the same tasks as plain ARC JSON files (<task_id>.json, {"train": [{"input", "output"}], "test": [{"input", "output"}]}).

Contents

• What the bank is
• How the tasks were made
• Eras and pipeline versions
• Design space: arms and draws
• Files
• Field reference: tasks
• Field reference: records
• Teacher difficulty
• Provenance flags
• What was removed or redacted
• Disclosures
• Intended uses
• Licence
• Code
• Citation

What the bank is

Each task is a set of training input/output grid pairs and one or more test pairs, in the format of ARC-AGI (grids up to 30×30, colours 0–9). Every task here passed the generator's checks and was then committed to the bank by an explicit owner decision. The tasks were made to be new relative to the growing bank and plausibly admissible as ARC-AGI-2-style evaluation tasks: one coherent rule, inferable from the training pairs, with a single best-supported test answer.

Beside the grids, every task carries its design record: the idea it came from, why the selector kept it, the planner's rule with the rival rules it had to defeat, the blind solver's reading, the judge's decision, any repairs, and every model call's parsed response.

How the tasks were made

The final pipeline (v1) runs these stages for each task. All stages are model calls except where noted.

1. Arms. Each idea call starts from an arm, a property of the task or of what solving it demands (for example "marks that direct" or "a small world with laws"). An arm never fixes a rule; the model invents the rule inside it. Property slots, content/skill/structure lines, size rungs and small draws are layered on top (see Design space).
2. Ideas, checked against the nearest bank tasks. The idea model explores, sketches, then looks up the nearest committed bank tasks and replaces sketches that are already covered (a look-up-and-replace loop), before committing a kept idea (idea_kernel_json).
3. Selector. A selector sees a window of kept ideas with their nearest bank references and rules each one eligible or not, with a reason and the useful contribution over the bank (selector_* fields).
4. Planner with rival rules. The planner writes a frozen plan: the central rule, invariants, the exact training and test layout, and the strongest simple rival rules, each with the evidence in the pairs that defeats it (central_rule, invariants, rival_rules).
5. Model-written grids. A realizer model writes every grid from the frozen plan. No code builds the grids.
6. Independent re-derivation. A second call gets the plan's rule but not its answers, re-derives the test outputs, and code compares them exactly with the realizer's answers. Only the test answers are code-checked; training outputs are checked by a model call and, indirectly, by the blind solve.
7. Blind solve. A new call of the solver model, given only the grids, infers the rule and predicts the test output, listing plausible alternative readings and flags (blind_* fields).
8. Judge. When the blind solve fails or flags a serious different-output alternative, a judge model decides whether the intended rule is clearly best supported, and may ask for a repair (judge_* fields).
9. Repair. A bounded repair call edits the task; the repaired task is checked again (repair_count, repair_instructions).
10. Bank. Verified tasks are committed only by an explicit owner decision, in commit sets (commit_set_id).

A deterministic palette step (code) may permute colours after planning so that backgrounds and roles vary across the bank (palette_remap). The planner's and realizer's own call records keep the colours those models wrote; the lifecycle record and the tasks grids use the final colours. Plans also refer to colours by role placeholders such as @ink_a or @background.

Earlier pipeline versions differ: they used shard and global selectors instead of the look-up loop, some used two-model editorial boards instead of the judge, and the earliest have no selector record at all (see Eras).

Models, as recorded per call (records.model, tasks.models): in the final pipeline gpt-6.1-sol (via the Codex CLI) plans, builds, re-derives and does every primary blind solve; gpt-6-astra runs the judge, ambiguity repairs and some second blind solves. Earlier versions also used gpt-6-sol, gpt-5.6-sol and gpt-5.6-terra.

Eras and pipeline versions

era is v1 for tasks committed on or after 2026-10-01 (the final pipeline) and pre-v1 before. pipeline_generation is a coarser label derived from source_pipeline:

pipeline_generation	Commit dates	Tasks	Notes
lean	07-31 – 08-05	25	first lean authoring pipeline; batch selector; editorial boards
v4	08-04 – 09-05	307	v4.x experiments (supported departure, episode-joint, functional scale, …); boards
e-series	08-14 – 08-31	733	E11–E22 experiments and the E18 production factory; shard/global selectors; boards
astra	09-06 – 09-15	764	Astra programme: arm-bank selector, broad arms, boardless verification from 09-11
astra-routine	09-14 – 09-19	672	routine production runs r10–r21
r23	09-30	173	two-planner batch on gpt-6.1-sol; committed same-idea siblings
v1	10-01 – 10-28	14,796	final pipeline: look-up idea loop, property arms, judge + repair

1,512 early tasks (before the production blind-check records) have no blind_performance record (has_blind_checks = false); their blind results are still in blind_rule and the lifecycle record.

Design space: arms and draws

A task carries one primary arm; in the T-type b17 batches also a family; up to three property slots; at most one content line, one skill line and one structure line; usually a size rung; and a few per-idea draws. These are recorded as they were drawn; a recorded property is an instruction the idea model received, not a verified property of the task.

Primary arms (primary_arm; 1,239 early tasks have none):

Arm	Fixes	Arm	Fixes
GEO	spatial geometry: where things are, face, reach, align	WORLD	a small world with consistent laws; answer = state reached
INTERACT	two or three processes act at once	SEE	seeing how a picture is organised
JUDG	contextual judgement: which cue or role matters here	DIRECT	marks act through their form (where, which way, how far)
SEM	a meaning learned from how the examples use it	LEVELS	organisation within parts and among parts
OPEN	no direction	BOARD	part of each input is a reference board
RHYTHM	the true rule of a repetition	J	joint inference over all the pairs
PER	what counts as a unit	ABS	a relationship the pictures determine but never draw
EXEMPLAR	a worked instance inside each input	SIGNAL	structure under systematic interference
FORM	a small logic puzzle taught by the grid	DISC	the obvious reading is wrong or incomplete
TEMPLATE	copies of a template placed by the picture	RESTORE	restore what is missing or covered
GEN	build the answer from given material	H_COMPOSE	sustained linked work
CONTRAST	a controlled comparison separates the rule from a rival	H_REASON	demanding dependent reasoning
VIEWS	two compatible readings at once	T	a derived consequence ("logical leap")
ACC	accessible: direct route, real insight	D1	exactly one demonstration
INVERSE	reason backwards to what produced the input	SPREAD	6–9 pairs, each showing part of the rule
STAGES	the pairs form a chain of states	EXEC	accessible rule, substantial execution
ACROSS	one relation across different kinds of picture	AIM	a condition on the result picks the answer
H_DISC	hard discovery, easy application

Retired pre-v1 arms: C (open, bank-conditioned), I1 (independent exploration), COMPACT, EXP (functionally expansive), MANY, XFER (supported transfer), REF_STYLE (general character of ARC evaluation tasks, described in prose only; the card held no evaluation task or ID), RICH.

Families (family, b17 T-type batches): SIM (simulation), LEGEND (key in each input), ENCL (enclosure), FIT (fitting), SYMSEQ (structure completion).

Property slots (property_slots): CONSTRUCT, DIGEST, EXTENT, SCENE (output); PACKED, BUSY (scene); VACANCY (evidence); KEY, CHAINED, MINIMAL, DISTRIBUTED, INSTRUCT (episode); IGNORE (relevance); COLOURFUL, PAYLOAD, MONO (colour); EASIER, LIGHT (demand); MEASURE (content); JOINED (structure); DERIVED (test); ONE (one demonstration pair).

Content lines (content_line): MARKS, PROCESS, TRACE, RELATION, SETTLE, INGRID, QUIET, DEPART, PRECISE, FORCED, COINCIDE, REFRAME. CONTROL marks the matched-control arm of a line screen (no line). Skill lines (skill_line): RECURSE, GRAPH, AUTOMATON, RANK, MATCH, EMIT, QUANTITY, GROWTH, SYMMETRY, CUED, NOISY. Structure lines (structure_line): SHAPE, RELEVANCE, RECOMBINE, ELIMINATE, PARSE, VARY.

Size rungs (size_rung): R1 (test answer about 150–300 cells), R2 (300–700, test larger than training), R3 (450–750, many dependent decisions), R4 (about 30×30). size_arm is large/small in the weakness runs.

Draws: draw_pose (instances turned, mirrored or resized across examples), draw_canvas (square / margin / both), draw_edge and draw_roles (drawn or control: things cut by the border; a colour with different roles in different grids), draw_colour_roles (vary or v1 colour instruction), draw_teach (plain teaching), draw_gate (the retired right-twice gate arm, see flags), draw_depart (first test meets an unseen situation), draw_fence (the weakness-line fence), route / route_overlay (planner route and scale overlay such as XFER, MANY, COMPACT).

Files

Path	What	Size
data/tasks/tasks-00000.parquet	tasks config: one row per task	50 MB
data/records/calls-00000.parquet	records config, record_type = model_call	223 MB
data/records/lifecycle-00000.parquet	records config, record_type = lifecycle	193 MB
arc/arc_tasks.zip	17,470 ARC JSON files	11 MB
prompts/templates/	prompt templates of the final pipeline (326 files)	1.5 MB
prompts/manifest.json	template list with SHA-256

Parquet files use zstd compression. Grids are list<list<int8>>.

Field reference: tasks

Identity and provenance

Field	Type	Meaning
task_id	string	bank task ID (also the ARC file name)
title, concept_summary	string	one-line title and concept, as recorded at commit
intended_rule	string	the task's rule as recorded at commit, in final colours
commit_set_id	string	owner commit set the task entered the bank with
batch	string	generation run (batch) ID
commit_date	string	YYYY-MM-DD of the commit set
era	string	v1 (from 2026-10-01) or pre-v1
pipeline_generation, source_pipeline, search_mode	string	pipeline version labels
project_stage	string	stage_3 for the production stage (from r23), else null
bank_status	string	boardless_verified (no editorial grade), core_quality or reserve_quality (board era)
quality_grade, editorial_mode	string	unassigned / bypass for boardless tasks

Grids: train, test (list of {input, output}), n_train, n_test.

Models

Field	Meaning
generation_model, generation_effort	idea model and reasoning effort, as recorded
models	list of {role, stage, model, reasoning_effort, n_calls} over every recorded call of the task
n_model_calls, call_record_ids	number of linked call records and their record_ids in records

Roles: idea, selector, planner, realizer, technical_verifier (independent re-derivation), blind_solver, judge, repair, audit (pre-v1 mechanism audits), editorial_board and research_review (pre-v1; content withheld).

Design: primary_arm, experiment_arm (pre-v1 experimental arm label such as single, treatment, control), family, modifiers (all idea modifiers as recorded), property_slots, skill_line, content_line, structure_line, size_rung, size_arm, route, route_overlay, draw_* (see above).

Idea and selector

Field	Meaning
idea_kernel_json	the kept idea (kernel) as JSON: central relation, recipe, what is new, risks
idea_central_relation	its central relation
selector_stage	which selector call assessed it
selector_eligibility	the selector's verdict on the idea (plausible, select, …)
selector_reason	the selector's reason
selector_useful_contribution	the selector's statement of what the idea adds over the bank (v1 and Astra)

Planner

Field	Meaning
central_rule	the planner's central rule (role placeholders such as @ink_a)
invariants	the plan's invariants
rival_rules	list of {rule, evidence_that_defeats_it, fits_every_training_pair, predicts_a_different_test_output, comparably_simple}

Blind solve (the last recorded blind response)

Field	Meaning
blind_rule	the rule the blind solver inferred
blind_alternatives_json	its strongest plausible alternatives (JSON, predicted grids removed)
blind_serious_alternative	it reported a serious alternative with a different test output
blind_unsupported_guessing	it reported that the test needs unsupported guessing
blind_confidence	its stated confidence
blind_matched_answer	its prediction matched the intended answer
blind_primary_result	matched / mismatched for the production primary blind solve
has_blind_checks	the task has a production blind-check record

Judge and repair

Field	Meaning
judge_decision	last recorded adjudication: clear, repairable (a repair followed and was re-verified), or one_answer_supported (lean era)
judge_failure_kind	the judge's diagnosis of the blind failure (execution, discovery, …)
judge_reason	its reason
judge_intended_rule_supported, judge_comparable_rival	its two key findings
evidence_resolution	how the answer evidence was cleared: ordinary_primary_clear, adjudicated_clear, rule_preserving_repair_reverified_clear, right_twice_clear, …
repair_count, repair_instructions	number of repairs and the instructions given
overruled_credible_rival	the final blind solve recorded a credible rival (different test output, fits every training pair, well supported, comparably simple) that the pipeline overruled; null without blind checks
credible_rival_cleared_by, n_credible_rivals	adjudication, right_twice or blind_match_no_adjudication; count

Teacher difficulty: teacher_model, teacher_draws, teacher_correct, teacher_solve_rate, teacher_pass_at_2 (see Teacher difficulty).

Provenance flags: eval_near_twin, admitted_via_right_twice, owner_override, owner_override_kind, source_portfolio_status, owner_editorial_override, excluded_from_training, excluded_from_training_reason (see Provenance flags).

Other: palette_remap (one-line summary of the colours the palette step permuted, e.g. colours remapped 0->7, 7->0).

Field reference: records

One schema for both record types.

Field	Meaning
record_id	call-… (hash of stage, call ID and response) or lifecycle-<task_id>
record_type	model_call or lifecycle
task_ids, n_tasks	bank tasks whose dossier holds this record. Selector and idea calls cover a window of ideas, so one call can serve several tasks; it is stored once
stage, role	pipeline stage (e.g. astra_concrete_plan_v3) and role
model, reasoning_effort, provider	as recorded in the call's request
call_id, parent_ids	call ID and the candidate/kernel IDs it was made for
prompt_template_version, prompt_template_hash, prompt_hash	template identity (match prompts/manifest.json for v1 templates)
withheld_reason	set when the response is not shipped (see below)
redactions	JSON counts of redactions applied to this record, or null
json	the parsed model response (model calls) or the lifecycle record, as a JSON string

Lifecycle record (json of a lifecycle row): {task_id, registry_entry, review, authoring_extra, dropped_fields}.

• review is the task's full candidate record: kernel, editorial brief, selection note, stage history, plan, realization, final task, deterministic and technical diagnostics, technical results, blind results, answer evidence, adjudication, difficulty versions, weakness-line checks, terminal artifact, and a palette_treatment_summary.
• registry_entry holds bank-registry fields not already in review; authoring_extra holds authoring-file fields that differ from review.
• Repeated large sub-objects are stored once; later copies are {"$same_as": "<JSON path of the first copy>"}.

Model-call responses are the models' structured outputs (JSON). Prompts, raw responses, transport logs, stderr, timing and schema snapshots are not included.

Teacher difficulty

DeepSeek V4.1 Flash 1017 (an open model) solved the bank tasks during trace generation, with the standard prompt and maximum reasoning effort. Each draw is one answered attempt at one test input, on the original task or on a geometric variant (rotation, reflection, transpose). Cut, empty or malformed calls are excluded.

Field	Meaning
teacher_draws	answered draws (0 for 2 tasks never drawn)
teacher_correct	correct draws
teacher_solve_rate	mean over test inputs of the per-input share of correct draws
teacher_pass_at_2	unbiased pass@2 (two attempts per test input), mean over test inputs; null if any test input has fewer than 2 draws

Across the bank the mean solve rate is 0.55 and the mean pass@2 is 0.66; 24% of tasks were never solved and 33% always. For comparison, with the same prompt and settings the model scores 98.1% pass@2 on the 1,000 ARC-AGI-2 training tasks.

Caveats.

• Draw counts vary (1–20; median 4). Some sampling rounds drew adaptively, giving more draws to tasks the model had failed, so draw count is not independent of difficulty, and rates from few draws are noisy.
• Variants are pooled with originals; a geometric variant can be easier or harder than the original.
• One open model at one setting is a narrow difficulty signal; it measures difficulty for that model, not for people.
• The trace-generation rounds were not designed as a benchmark; matched fixed-design numbers are in the paper.

Provenance flags

Flag	Values	Meaning
eval_near_twin	twin (2), near (37), none (7,870), unchecked (9,561)	Result of our check of every public ARC-AGI-2 evaluation task against the 7,909 bank tasks committed by mid-October (7,916 registry tasks including 7 later quarantined). twin: one program solves both tasks. near: the same core mechanism with one more clause or a changed setting. Tasks committed later were not checked, so the 39 flagged tasks are a lower bound.
admitted_via_right_twice	128 true	Admitted between 10-16 and 10-19 through the retired "right twice" gate: two correct blind solves cleared a flagged rival without review.
owner_override, owner_override_kind	314 true (crowding 244, same_procedure 70)	Pre-v1 tasks committed by owner override although the portfolio review held them as crowded or as a same-procedure duplicate.
source_portfolio_status	include_now, hold_crowded, same_procedure_duplicate	The original pre-v1 portfolio placement. 15 tasks of the 09-15 backlog commit carry a held placement without an override flag (their saved grades were reused at commit).
owner_editorial_override	3 true	Editorial rejections committed by explicit owner approval (09-10).
excluded_from_training, excluded_from_training_reason	9 true	Excluded from our training sets after a later ambiguity review. The exclusion list has 13 IDs; the other 4 were held at commit and are not in the bank.
overruled_credible_rival	416 true	See the judge fields above.

What was removed or redacted

ARC-AGI-2 evaluation content. No evaluation task ID, no evaluation grid and no text shared with our evaluation-task annotations appears in this release. Where it entered the records, we removed it:

Where	What we did	Count
Selector calls up to 10-14	Their reference lists included public evaluation tasks (real:<id> with rule texts). Each comparison with an evaluation reference keeps only its relationship label (distinct, useful_relative, …); its ID becomes real:[eval-redacted] and its text is replaced. In every selector response that saw evaluation references (1,238 of 2,205 selector calls), sentences that mention real or evaluation references are replaced. The same applies to selector assessments, editorial briefs, selection notes and sibling lists inside lifecycle records of tasks committed before 10-15.	899 references and 1,720 sentences in call records; 613 and 809 more in lifecycle records and selector_* fields (partly the same text)
Editorial-board calls (pre-v1)	The boards were shown six public evaluation tasks with their test answers as anchors. All 644 board responses are withheld (metadata kept, json null), and the boards' verdict texts are dropped from lifecycle records.	644 calls
Research-review calls (pre-v1, difficulty_judgment_research_*, broad_research_*, lane_research_*)	Withheld in full.	1,067 calls
Lifecycle calibration_task_ids (earliest tasks)	Dropped: they listed the evaluation tasks used as idea-prompt calibration examples.	25 tasks
Any string, anywhere	Strings holding an evaluation ID, and sentences sharing 8 or more consecutive words with our evaluation-task annotations or with the selector's own descriptions of evaluation tasks, are replaced. Shared 8-word phrases that are generic layout language (two or fewer content words, or also produced by models with no evaluation exposure, such as "upper left, upper right, lower left and lower right") are not counted.	5 strings

Redacted text reads [redacted: ARC-AGI-2 evaluation reference]. Each record's redactions field counts what was changed in it. A final scanner checked every shipped file (every string, parsed JSON payload, file name and grid) for evaluation IDs, 8-word annotation overlaps and evaluation grids, with zero hits.

Not included. Prompts as sent (filled prompts), raw responses, transport logs, stderr, timing, schema snapshots, the dossiers' *.private.json scaffolding, and duplicate copies of shared calls. The full palette_treatment block (which repeats the plan, realization and task in both colourings) is replaced by a summary. The 438 verified but uncommitted tasks of the last run are not included.

Normalised. Local paths, run directories, account names and the host name were replaced with neutral values (a run path becomes its batch ID; account names become main). Run and batch IDs are kept, with account names inside them normalised the same way.

Disclosures

1. Evaluation content in generation prompts.
   • Idea prompts: from the first runs (07-28) until r23 (09-30), they carried descriptions of four public evaluation tasks per call as calibration examples.
   • Selector: until v1-b16 (10-14), it saw rule texts of public evaluation tasks as comparison references, so about 7,900 bank tasks were selected with them in context.
   • Planner: for about 440 of the 5,400 stage-3 tasks committed by 10-14, the selector's note on an evaluation comparison went verbatim to the planner. No evaluation ID reached a planner prompt.
   • From 07-28 to about 09-10, editorial boards scored generated tasks against six public evaluation tasks shown in full, test answers included. This affects about 1,300–1,450 early tasks, depending on how a shared board review is mapped to tasks.
   • In all, about 8,160 bank tasks (47%) had some evaluation content in at least one generation-stage prompt. No evaluation content has been in generation prompts since 10-15.
2. Near-copies of evaluation tasks. Judged against the 7,916 bank tasks of mid-October, 30 of the 120 public evaluation tasks have a twin (2) or a near-twin (28) in the bank; the 39 bank tasks involved are flagged in eval_near_twin. The later tasks were not checked, so this is a lower bound. Our tracing found no idea prompt that described the evaluation task its bank task resembles; the selector compared many of these ideas with the matching evaluation task after they were written and admitted them as useful relatives. We read them as convergent reinventions of common ARC ideas that the novelty guard let through, not copies. Pretraining familiarity with the public evaluation set cannot be ruled out.
3. Same-model checking. In the final pipeline gpt-6.1-sol plans, builds, re-derives and does every blind solve; only the judge and ambiguity repairs run on gpt-6-astra. The blind solve is a fresh call of the same model, so it partly measures self-consistency.
4. Other admissions.
   • 128 tasks came in through the retired "right twice" gate with an unreviewed flagged rival (admitted_via_right_twice). After a later ambiguity review we excluded 8 of them, and one other task, from our training sets (excluded_from_training, 9 bank tasks; the exclusion list's 4 other IDs were held at commit and are not in the bank).
   • 314 pre-v1 tasks were committed by owner override despite crowding or same-procedure flags (owner_override).
   • r23 committed same-idea siblings.
   • 568 tasks were kept on the judge's word after a failed blind solve.
   • Only test answers are code-checked; training outputs are checked by a model call and, indirectly, by the blind solve.
   • No human panel reviewed the tasks. Quality judgements in the paper come from model raters.

Intended uses

• Training and evaluating ARC-style reasoning systems (supervised fine-tuning, reinforcement learning, curriculum design), and studying difficulty with the teacher columns.
• Studying LLM task generation: how ideas, rival rules, blind solves and repairs relate to the final task.
• When you report a score on the public ARC-AGI-2 evaluation set for a system trained on this bank, report it split by eval_near_twin: with and without the 39 flagged bank tasks in training, or on the evaluation tasks with and without a flagged twin. Because 9,561 later tasks were not checked, treat even the split as an upper bound on cleanliness.
• Not intended as an evaluation set for ARC-AGI-2 claims, and not a substitute for human-verified tasks.

Limitations: rules and judgements were written and checked by models; a small share of tasks may still admit a second reasonable answer (overruled_credible_rival marks 416 known cases). Recorded arms and lines are instructions to the idea model, not verified properties of the task.

Licence

This dataset is dedicated to the public domain under Creative Commons CC0 1.0 Universal (CC0 1.0, https://creativecommons.org/publicdomain/zero/1.0/). To the extent possible under law, Hazem Lashen has waived all copyright and related rights in it. You may copy, modify and distribute it for any purpose, including commercially, without asking permission or giving credit. A citation is welcome but not required. See LICENSE.

Model outputs. The tasks, plans, rules, judgements and other records were generated by third-party models, mainly OpenAI's gpt-6.1-sol and gpt-6-astra through the Codex CLI, with embeddings for the bank look-up via OpenRouter; the difficulty columns come from DeepSeek V4.1 Flash solves. The CC0 dedication covers our rights in the dataset. The model providers' terms may also apply to model-generated content, for example terms on using outputs to develop competing models. Check those terms for your use.

Code

The generator code, with the training code, is released under the MIT No Attribution licence (MIT-0) at https://github.com/hl3372/arc-agi-experience.

Citation

@misc{lashen2026arctaskbank,
  title  = {ARC Task Bank: LLM-generated ARC-AGI tasks with their design records},
  author = {Lashen, Hazem},
  year   = {2026},
  url    = {https://huggingface.co/datasets/hl3372/arc-agi-task-bank},
  note   = {Accompanies an ARC Prize 2026 paper; the paper citation will be added here}
}