ServiceNow-AI/cascade_bench

CascadeBench: Do Enterprise Systems Need Learned World Models?

🎉 Accepted to NeurIPS 2026: The Fortieth Annual Conference on Neural Information Processing Systems (Main Track)

A reasoning-focused benchmark for predicting enterprise business-rule cascades, built on synthetic schemas with rule-level attribution of every field change

About

In enterprise systems, the dynamics come from tenant-specific business logic that varies across deployments and changes over time. Business rules, workflows and schema defaults decide what happens when a record changes. The same action can have different effects on different instances.

CascadeBench tests whether a model can predict those effects. Each example gives the current state $s_t$ and an action $a_t$. The model predicts the next state $s_{t+1}$: every field-level change across every table, including all changes made by the chain of business rules the action triggers.

The benchmark accompanies the paper Do Enterprise Systems Need Learned World Models? The Importance of Context to Infer Dynamics. The paper finds that:

• Offline-trained world models perform well in-distribution but degrade as configurations change. Enterprise discovery agents stay more robust because they read the active rules at runtime.
• Having the rules is necessary but not sufficient. Accuracy still drops sharply as cascades compose, even when the active rules are in the prompt. Multi-step rule composition limits performance more than retrieval does.

Key Features

• 🧪 Real dynamics. A live ServiceNow rule engine produced every transition. Nothing is simulated.
• 🏷️ Rule-level attribution. A custom execution log traces each field change in the audit log to the business rule that caused it.
• 🔒 Synthetic surface form. Table and field names are freshly generated with a u_ prefix, and reserved product namespaces are excluded. Models can't rely on recalling table structures they may have seen in pretraining.
• 📦 Full context per example. Each example includes table schemas, business rules, seed records and supporting records. You control how much of this the model sees.
• 🧹 Clean ground truth. Audits are restricted to content fields. System IDs, timestamps and bookkeeping fields are removed.
• ✅ Validated cascades. Every business rule passes 14 deterministic checks (schema correctness, cycle detection, filter validity, script safety) and is verified through execution.

Code

• Discovery agent: ServiceNow/SyGra › wow_state_predictor_da
• Dataset construction and evaluation code: coming soon! 🚧

Dataset Summary

Samples	37 (one per workflow domain)
Domains	37, e.g. accounts_payable_processing, change_management, incident_escalation
Tables per sample	~10 synthetic tables with foreign-key relationships
Business rules per sample	4–7 (204 total)
Cascade topologies	linear (21), flat (16)
Triggering operations	update (29), insert (8)
Audit records (deduped)	1,395 field-level changes
Split	train

Complexity Tiers

Ground-truth changes are stratified into three tiers:

Tier	Name	What it covers	Metric
T1	Schema-deterministic	Defaults, constraints and choices on the action's own table	IoU(T+F)
T2	Rule-composable	Cross-table cascades that require at least one business rule to fire	IoU(T+F)
T3	Execution-inferred	Conflicts where two or more rules write different values to the same field	Strict IoU on (table, field, value)

Field Descriptions

Field	Type	Description
domain	string	Workflow domain. Unique per row, so it can serve as a sample ID
topology	string	Cascade topology (linear or flat)
total_brs_fired	int	Number of business rules that actually fired
expected_br_count	int	Number of business rules expected to fire
audit_count	int	Number of deduplicated audit records
raw_audit_count	int	Number of raw audit records
tool_name	string	The action invoked, $a_t$
parameters	string (JSON)	{table_name, operation, fields} for the action. fields keys are domain-specific
seed_data	string (JSON)	Initial state of the target record. Empty for insert actions
supporting_data	string (JSON)	Map from related table name to its rows
schema	string (JSON)	Map from table name to its column schema, including foreign keys
business_rules	list[struct]	name, fires_on_table, filter_condition, trigger_sequence, trigger_type, order, script
ewm_logs	list[struct]	Execution-log entries attributing each change to a rule (u_br_name, u_table_name, u_field_name, u_old_value, u_new_value, …)
audits	list[struct]	Ground truth $s_{t+1}$: deduplicated field-level audit (tablename, fieldname, oldvalue, newvalue, documentkey)
raw_audits	list[struct]	Raw field-level audit, same shape as audits

Table and field names in the four JSON-string columns (parameters, seed_data, supporting_data, schema) differ per domain. They are stored as serialized JSON to keep the Arrow schema stable. Call json.loads() to use them.

Usage

from datasets import load_dataset
import json

ds = load_dataset("ServiceNow-AI/cascade_bench", split="train")

row = ds[0]
print(row["domain"], row["tool_name"])

schema = json.loads(row["schema"])        # table -> column schema
params = json.loads(row["parameters"])    # the action a_t
seed = json.loads(row["seed_data"])       # current state s_t (target record)
rules = row["business_rules"]             # rules that may fire
gold = row["audits"]                      # ground-truth field changes s_{t+1}

Evaluation Settings

The paper evaluates three settings, which differ in how much context the model gets:

Setting	Context given to the model
Direct	Action and state only. No rules and no retrieval
Discovery Agent	Retrieves rules and schema from the system at inference time
Oracle	Active business rules supplied in the prompt

Example Use Cases

• Benchmark world models and transition predictors on enterprise systems whose dynamics are specific to each deployment.
• Compare internalized and runtime-discovered dynamics by varying which context fields the model sees.
• Study multi-step rule composition by using rule-level attribution to measure how accuracy drops as rule hops increase.
• Evaluate discovery agents that query schemas, workflow definitions and business rules before acting.

Citation

@misc{nair2026enterprisesystemsneedlearned,
      title={Do Enterprise Systems Need Learned World Models? The Importance of Context to Infer Dynamics},
      author={Jishnu Sethumadhavan Nair and Patrice Bechard and Rishabh Maheshwary and Surajit Dasgupta and Sravan Ramachandran and Aakash Bhagat and Shruthan Radhakrishna and Pulkit Pattnaik and Johan Obando-Ceron and Shiva Krishna Reddy Malay and Sagar Davasam and Seganrasan Subramanian and Vipul Mittal and Sridhar Krishna Nemala and Christopher Pal and Srinivas Sunkara and Sai Rajeswar},
      year={2026},
      eprint={2605.12178},
      archivePrefix={arXiv},
      primaryClass={cs.AI},
      url={https://arxiv.org/abs/2605.12178},
}