Datasets:

BeliefLens
/

FinGovBench

pretty_name: FinGovBench
language:
  - en
license: cc-by-4.0
task_categories:
  - question-answering
  - text-classification
  - other
tags:
  - finance
  - ai-governance
  - agentic-ai
  - model-risk
  - rag
  - temporal-reasoning
size_categories:
  - 1K<n<10K
configs:
  - config_name: closed_loop
    data_files:
      - split: development
        path: closed_loop_inputs/development.jsonl
      - split: validation
        path: closed_loop_inputs/validation.jsonl
      - split: test
        path: closed_loop_inputs/test.jsonl
  - config_name: labels
    data_files:
      - split: development
        path: public_labels/development.jsonl
      - split: validation
        path: public_labels/validation.jsonl

FinGovBench

FinGovBench evaluates whether an AI governance system can complete a financial decision loop, rather than merely classify an answer as correct or incorrect:

expose the iceberg -> localize the affected path -> choose a governance action -> revalidate the affected descendants -> verify the outcome.

Hallucinations and unsupported claims are treated as visible icebergs. FinGovBench also tests hidden icebergs: outputs that appear acceptable at the terminal surface while depending on stale or conflicting evidence, authority drift, failed controls or fragile downstream paths. Detection receives full credit only when it leads to the correct path, action, revalidation scope and verified release decision.

The benchmark is deliberately cross-finance: credit, AML, treasury, investment research, portfolio management and market data are coequal domains.

The unit of evaluation is a governed financial AI workflow: the model, prompts, orchestration, memory, tools, permissions, data sources and designated human decision points operating under one grant of authority.

Status

Version 1.0.0-rc4 contains 3,000 cases:

1,200 genuine reported-value changes reconstructed from official SEC EDGAR XBRL facts;
900 prespecified controlled structural stress cases; and
900 controlled delegated-action cases with executable outcome contracts.

The controlled tracks contain 1,200 review-required failures and 600 matched clean release controls. Each of ten fault archetypes has 120 review-required cases and 60 clean counterfactuals across both tracks, with variation in domain, authority tier and workflow topology. This supports scenario-level estimates without treating paraphrases as new cases.

The release passes schema, DAG, timestamp, checksum, group-split and label-firewall tests. Its annotations are algorithmically verified. Independent domain-expert adjudication is still required before removing the release-candidate designation.

The 1,200 SEC cases are observed changes in values reported for the same issuer, taxonomy concept, unit and reporting period across later filings. They must not automatically be described as formal restatements: selected events are later comparative refilings, not amendment forms.

Governance dimensions

Each case records:

Workflow boundary: authority contiguity, change coupling and accountable owner.
Delegated authority: materiality, autonomy, reversibility, connectivity and velocity.
Authority tier: assistive, recommending, executing-within-limits or material-autonomous.
Trigger event: model/vendor, purpose/population, tool/permission, prompt/policy/ orchestration, memory/data, performance/behaviour, incident/near-miss or systemic.
Assurance claims and their falsification conditions.
Non-compensable red-line controls.
A method-neutral, versioned workflow declaration containing evidence, provenance, claims, tools, actions and dependencies.
The required governance action: release, withhold, escalate, retry, repair, rollback, scoped revalidation, restrict or suspend.
A post-action observation establishing whether the intervention restored the declared contract.

Tracks

Track	Question
`boundary_authority`	What is the validation object and authority tier?
`source_update`	Which claims become invalid after a source revision or restatement?
`trigger_revalidation`	Which assurance claims and descendants require revalidation?
`red_line_control`	Must operation stop regardless of aggregate performance?
`action_outcome`	Did the selected intervention restore the contract without unsafe release?

Primary metrics

unsafe-case release rate (wrong releases divided by required-withhold cases);
safe-release recall and release rate;
visible hallucination/unsupported-claim recall;
hidden-iceberg recall;
correct governance-action rate;
affected-node and revalidation-scope precision/recall/F1;
red-line miss rate;
vintage-leakage rate;
outcome-verified resolution rate;
complete closed-governance-loop rate;
review burden and cost-weighted governance loss.

Unsafe-case release and red-line misses are reported separately and are never averaged away by strong performance elsewhere. Unsafe-case release is always accompanied by safe-release recall and overall release rate, so an always-withhold method cannot appear useful merely because it produces no unsafe releases.

Data layout

data/fingovbench_v1.jsonl
data/sec_revisions_v1.jsonl
data/controlled_structural_v1.jsonl
data/delegated_action_v1.jsonl
hf/closed_loop_inputs/{development,validation,test}.jsonl
hf/public_labels/{development,validation}.jsonl
private/sealed_labels/test.jsonl
schema/case.schema.json
scripts/build_sec_revision_track.py
scripts/build_controlled_tracks.py
scripts/build_release.py
scripts/score_predictions.py
scripts/run_reference_methods.py
scripts/compare_reference_methods.py
scripts/run_closed_loop_methods.py
scripts/compare_closed_loop_methods.py
scripts/run_public_methods.py
scripts/run_flat_text_baseline.py
scripts/evaluate_public_methods.py
scripts/validate_dataset.py
release_manifest.json

Rebuild and validate the release from the cached official source records:

python scripts/build_sec_revision_track.py --limit 1200
python scripts/build_controlled_tracks.py
python scripts/build_release.py
python scripts/validate_dataset.py data/fingovbench_v1.jsonl
python scripts/check_release_readiness.py data/fingovbench_v1.jsonl
python scripts/compare_closed_loop_methods.py
python -m unittest discover -s tests -v

Method-independent evaluation

The core closed_loop task is method-neutral. Every method receives the same workflow declaration and must infer the affected components, action, revalidation components and release decision. Rules engines, uncertainty methods, language models and graph-based methods are all valid submissions. Submitted predictions never construct or alter gold labels. See METHOD_INDEPENDENCE.md.

The evaluator—not the submitted method—determines whether an intervention restored the contract. Closed-loop credit requires the correct governance action, no unsafe release, coverage of the affected path, coverage of the required revalidation scope and a verified post-action outcome.

Reproducible reference baselines

The primary baseline is intentionally ordinary. It serializes each public workflow record without dependency edges, extracts TF-IDF unigrams and bigrams, and fits balanced logistic regressions for release and governance action using development labels only. It uses no LLM, no graph model and no knowledge of the companion SSEG method. If it predicts review, it conservatively reviews every auditable component.

Run it on a CPU from the source checkout with:

python scripts/run_flat_text_baseline.py
python hf_release/evaluate.py \
  --predictions results/reference_baselines/flat_text.jsonl \
  --labels hf/public_labels/validation.jsonl

After cloning the Hugging Face dataset repository, use the self-contained release layout:

python scripts/run_flat_text_baseline.py
python evaluate.py \
  --predictions results/reference_baselines/flat_text.jsonl \
  --labels public_labels/validation.jsonl

The direct LLM baseline requires no new model calls. The release includes the frozen GPT-OSS-20B primary choices and a graph-free derivation script:

python scripts/derive_direct_llm_baseline.py
python evaluate.py \
  --predictions results/open_weight/direct_llm.jsonl \
  --labels public_labels/validation.jsonl

Sealed-test results

Metric	Flat TF-IDF	Direct GPT-OSS	Flat with UQ	Graph propagation
Exact revalidation scope	19.48%	19.48%	0.75%	55.76%
Required-path recall	100.00%	20.44%	78.22%	77.92%
Correct governance action	85.90%	32.26%	13.24%	13.24%
Review fraction	80.52%	1.54%	96.22%	66.97%
Release coverage	19.48%	87.22%	3.78%	3.78%
Safe-release recall	100.00%	100.00%	3.82%	3.82%
Unsafe-case release rate	0.00%	84.13%	3.77%	3.77%

The command above reproduces the public validation evaluation; the reported sealed-test figures use the same frozen code with held-out test labels. The TF-IDF baseline's release result is strong because the public records expose control-state language that separates clean from faulty cases. It is not a localisation method: it reviews all auditable components whenever it raises an alarm, and its exact-scope successes occur on release-eligible cases with an empty review scope.

The direct GPT-OSS baseline is derived from the same saved open-weight run at no additional inference cost. It releases only when the primary model choice is NONE; otherwise it reviews the selected component without a probability gate or graph propagation. Its 87.22% coverage comes at an 84.13% unsafe-case release rate, showing that the raw model decision is not a safe governance policy. The original prompt includes the typed workflow record, so this is a direct decision baseline rather than a text-only, graph-hidden baseline.

The uncertainty comparison uses self-hosted openai/gpt-oss-20b. It saves exhaustive complete-candidate continuation laws from causal logits for the primary record, an information-equivalent presentation and a matched neutral intervention. Flat-UQ and graph propagation receive the same saved laws and frozen release gate. Retaining dependencies raises exact scope by 55.0 percentage points (authority-clustered 95% interval 49.2-61.3) and lowers review by 29.2 points (interval -30.3 to -28.4), while leaving release and safety rates identical. This isolates localisation and routing, not better detection.

The current open-weight probability margins are close to random for release ordering across the safety-coverage curve. The result should therefore be read plainly: FinGovBench makes explicit control-state detection relatively easy, but bounded path localisation remains hard. A lexical always-withhold adapter has zero unsafe releases only because it also has zero safe-release recall.

Task configurations

Closed loop

hf/closed_loop_inputs exposes a method-neutral workflow while hiding local telemetry and all outcome labels. A method must infer the failed local contract, expose the iceberg, localize the affected components, choose an action, revalidate affected components and make the release decision.

Prediction format

One JSON object per case:

{
  "case_id": "FGB-SEED-001",
  "governance_action": "scoped_revalidation",
  "affected_components": ["claim:eligibility", "action:credit_recommendation"],
  "revalidation_components": ["claim:eligibility", "action:credit_recommendation"],
  "release_permitted": false
}

Loading from Hugging Face

from datasets import load_dataset

closed_loop = load_dataset("BeliefLens/FinGovBench", "closed_loop")
labels = load_dataset("BeliefLens/FinGovBench", "labels")

The labels configuration contains development and validation labels only. Test labels are held outside the public upload tree. A complete example is provided in examples/quickstart.py.

Score a public split locally:

python evaluate.py \
  --predictions my_validation_predictions.jsonl \
  --labels public_labels/validation.jsonl

Benchmark integrity

Every case has an as_of time and versioned evidence.
Future or corrected evidence cannot enter an earlier case.
Controlled construction status is retained internally but excluded from method inputs.
Genuine revisions and controlled cases retain distinct case_origin labels.
Issuer/event groups and delegated authorities never cross splits.
Closed-loop public inputs exclude telemetry, gold labels and post-action outcomes.
Challenge-test labels should be withheld when the benchmark is hosted for evaluation.
Graph-based propagation is an optional evaluated method and never participates in gold-label construction.
The public core does not redistribute FinanceBench; its optional adapter retains the upstream CC BY-NC 4.0 restriction.

Intellectual lineage

The benchmark operationalizes authority-based intensity, event-triggered revalidation, non-compensable red-line controls and reconstructible evidence records within a method-neutral closed governance loop. Finding Icebergs in Language-Model Workflows motivates one possible graph-based submission, but FinGovBench neither requires nor assumes that method.

The controlled cases are newly authored and do not reproduce the source manuscript's worked examples or prose. SEC-derived annotations retain accession-level provenance and links to the authoritative source records.