---
type: "post"
id: "ai2-released-statebench-a-benchmark-splitting-state-tracking-2c9c2e"
slug: "ai2-released-statebench-a-benchmark-splitting-state-tracking-2c9c2e"
title: "Ai2 released StateBench, a benchmark splitting state tracking into four algebraic complexity tiers."
description: "Ai2 has released StateBench, an open benchmark and generation toolkit for evaluating how language models track changing state across sequences of assignments."
retrieval_nugget: "Ai2 has released StateBench, an open benchmark and generation toolkit for evaluating how language models track changing state across sequences of assignments. Its four task families vary in algebraic complexity while controlling several properties of the underlying traces, giving researchers a more structured way to test where state tracking breaks down."
published_at: "2026-11-04"
updated_at: "2026-11-07"
record_date: "2026-11-04"
date_kind: "published_at"
topics: ["models"]
entities: ["Ai2","StateBench","OLMo 3","OLMo Hybrid"]
related_patterns: ["ai-engineering-evaluations-are-splitting-into-task-specific"]
novelty_label: "same_event"
prior_refs: ["https://newruntime.com/posts/statebench-testing-how-language-models-track-state-changes-afffa2/","https://newruntime.com/posts/statebench-testing-how-language-models-track-state-changes-f7c04b/"]
source_url: "https://github.com/allenai/state-bench"
source_urls: ["https://github.com/allenai/state-bench"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:ai2-released-statebench-a-benchmark-splitting-state-tracking-2c9c2e"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/ai2-released-statebench-a-benchmark-splitting-state-tracking-2c9c2e/","markdown":"https://newruntime.com/posts/ai2-released-statebench-a-benchmark-splitting-state-tracking-2c9c2e.md","json":"https://newruntime.com/posts/ai2-released-statebench-a-benchmark-splitting-state-tracking-2c9c2e.json"}
markdown_url: "https://newruntime.com/posts/ai2-released-statebench-a-benchmark-splitting-state-tracking-2c9c2e.md"
---

# Ai2 released StateBench, a benchmark splitting state tracking into four algebraic complexity tiers.

## Retrieval answer

Ai2 has released StateBench, an open benchmark and generation toolkit for evaluating how language models track changing state across sequences of assignments. Its four task families vary in algebraic complexity while controlling several properties of the underlying traces, giving researchers a more structured way to test where state tracking breaks down.

## Summary
Ai2 has released StateBench, an open benchmark and generation toolkit for evaluating how language models track changing state across sequences of assignments. Its four task families vary in algebraic complexity while controlling several properties of the underlying traces, giving researchers a more structured way to test where state tracking breaks down.

## What happened
The StateBench repository describes a system for generating reproducible state-tracking evaluations from canonical assignment traces, rendering each trace in multiple surface forms, and preparing complete dataset repositories for publication. It is released under the Apache-2.0 license. The supplied material does not give a release date, benchmark scores, or pricing; the repository presents the project as research infrastructure and dataset tooling rather than a hosted service.

Each sample begins with a periodic source trace. The benchmark derives three additional families from that same trace: solvable, aperiodic, and r-trivial. The repository defines a hierarchy, r-trivial ⊂ aperiodic ⊂ solvable ⊂ periodic, in terms of group complexity. In the periodic family, assignments can copy values from other variables. In the solvable family, those references are represented as modular increments to a variable’s own current value. In the aperiodic family, the operation is replaced by the copied value; in r-trivial, each assignment is replaced by the first value ever assigned to its target.

The design aims to make comparisons interpretable. For periodic, solvable, and aperiodic variants, the value in every register after each step and the final state remain the same; the families differ in what an update reads. The benchmark says the families also share the set of values visited, so one is not harder merely because it spans more of the value vocabulary. It preserves assignment count, targets, query, formatting choices, and padding condition when deriving the simpler families. The repository notes that reference assignments use eager copy semantics, not persistent aliases, and that increments wrap modulo the number of values.

Experiments can select which families to emit, with all four as the default. Train/test disjointness is checked against all derived families, and samples can be joined by source identifiers. Some rendering formats cannot truthfully express modular increments; those skip the solvable family, while configurations without a suitable formatter can use r-trivial, aperiodic, and periodic. The repository includes scripts for dataset generation, staging, and optional Hugging Face publication, plus optional tokenization support. The provided source does not establish model performance results or a single fixed dataset size.

The project also specifies practical constraints on rendering. The solvable family requires a formatter with an increment-assignment template and a value vocabulary literally ordered as "0", "1", and onward, so that the modular arithmetic remains faithful to the generated trace. The repository supplies modular variants of integer-code and spreadsheet-cell formats for this purpose. Surface seeds are keyed to formatter names, which the repository says lets additional formats be introduced without changing existing rendered examples byte-for-byte.

## What the archive adds
The archive already covered [StateBench: Testing how language models track state changes over long documents](https://newruntime.com/posts/statebench-testing-how-language-models-track-state-changes-afffa2/), including the reported advantage of recurrent and hybrid models on harder tasks. This repository release is the same known story, with implementation detail about how the benchmark constructs and controls its four task families rather than a wholly new event.

## Trend signal
This supports the need for more discriminating evaluation artifacts: StateBench controls properties of the examples while varying one structural dimension, making results easier to interpret than a single undifferentiated score. No supplied SITE_PATTERNS thesis specifically covers benchmark construction for state tracking, so no pattern link is appropriate.

## Why it matters
For teams building systems that must maintain state over long sequences—whether in workflows, simulations, or tool-mediated tasks—the benchmark offers a way to test more than whether a model gets a final answer right. Different update structures can expose different failure modes: copying another variable’s current value, applying a local transformation, or handling updates that do not require cross-variable reads.

The controlled trace design may also help researchers avoid attributing a result to the wrong cause. If families share their visited values and much of their formatting and trace structure, differences in performance are more plausibly related to the update rules. That does not make the benchmark a direct proxy for every production workload, but it can inform architecture research and evaluation design. Teams should treat it as a diagnostic suite, not as proof that a model will reliably maintain state in a deployed agent.

This distinction is useful when choosing an evaluation plan. A team can ask whether an observed failure comes from longer context, a vocabulary change, the presentation format, or dependence on another changing variable. StateBench does not answer all of those questions automatically, but its shared-source construction makes that investigation more defensible than comparing unrelated synthetic datasets with different distributions. Earlier coverage: [StateBench: Testing how language models track state changes over long documents](https://newruntime.com/posts/statebench-testing-how-language-models-track-state-changes-afffa2/).

## Limits and uncertainty
The supplied repository excerpt explains generation and configuration, but it does not provide the full paper’s experimental findings, quantitative scores, or evidence that benchmark performance predicts success in deployed applications. The benchmark’s controlled assignment traces are deliberately structured and may not capture messy real-world state, ambiguous instructions, tool errors, or changing schemas. Some formatters cannot render every family, and the excerpt does not specify the dataset’s total examples, token-length distribution, or an evaluation protocol that would make model comparisons directly comparable. Those details should be checked before using StateBench as a release gate.

## Skill to build now
Add a small state-tracking test to an existing evaluation harness. Define a sequence of explicit updates, preserve a known final state, and include variants where an update reads a different variable rather than only replacing a value. Record the trace, expected answer, and formatting version together. This will not reproduce StateBench’s algebraic construction, but it can reveal whether a system fails on dependency structure rather than simply on longer prompts.

## Reader takeaway
StateBench’s contribution is not only another score: it separates state-tracking tasks into four related forms while preserving key properties of shared source traces. Researchers can use that structure to ask which kinds of update dependencies challenge a model, but should not assume a benchmark win transfers automatically to production state management.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Models](https://newruntime.com/topics/models.md): Explore the models topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)