Entendre/Crypto-Accounting-Bench

Crypto Accounting Bench

Crypto Accounting Bench (CAB) asks a narrow question with a checkable answer: given one crypto-asset transaction and the evidence that surrounded it, can a model reconstruct the complete journal entry the organization actually posted?

The target is the entry that exists in that organization's ledger, chosen from that organization's own chart of accounts, rather than the entry a textbook would prescribe. The same on-chain movement is booked differently by different organizations, so the convention has to be inferred from the evidence supplied with the task.

• 118 tasks, one self-contained directory each
• 7 pseudonymized organizations, each with its own chart of accounts, a median of 569 accounts per task
• 8 recorded source-system labels, 21 assets, 10 chains plus an exchange-only context, and 2 base currencies
• 246 non-zero reference lines across the set
• Every task carries a frozen weighted rubric and a graded expected answer

This is the same 118-task population evaluated in the research paper, so the paper and this release describe one benchmark population.

Links

Scoring harness	examples/run_benchmark.py in this repository, dependency-free
Method and metric definitions	this card, under Evaluation
Research paper	Crypto Accounting Bench: Evaluating Frontier and Open-Weight Models on Crypto-Asset Accounting Tasks, Entendre Finance, September 2026. arXiv:2609.14811.

This release is self-contained. The evidence, the answer key, the frozen rubrics and a deterministic scorer all ship here, so a comparable result can be produced from these files alone. The judge-based pipeline that produced the paper's headline numbers is an internal tool and is not publicly released, so what you can reproduce from this release is the deterministic lower bound described under Evaluation.

Privacy. This release is a transformed derivative. Every organization, legal entity, person, counterparty, venue name, bank, account name, account number, address, transaction identifier, asset ticker, chain, amount, quantity and timestamp carries a synthetic value, assigned consistently across the whole dataset. Generic accounting terminology and some public categorical labels are published as recorded, among them the source system's exchange enum in source.exchangeSourceType, which names a real venue in 23 tasks. The evaluated corpus uses pseudonymized identifying names; this public copy applies a further one-way transformation, and the mapping back to source values is not released and cannot be derived from these files. These measures do not establish complete anonymity. Records here must not be read as literal records of any real organization. See TRANSFORMATION_REPORT.md and PUBLICATION_AUDIT.md.

License: Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0). You may share and adapt this dataset with attribution, for non-commercial purposes.

Layout

README.md                     this file
DATASET_CARD.md               dataset card
TRANSFORMATION_REPORT.md      what was transformed, and how
PUBLICATION_AUDIT.md          privacy audit results + authorization status
manifest.json                 counts, composition, per-file checksums
schema/expected_answer.schema.json
examples/example_input.json
examples/example_expected_answer.json
examples/run_benchmark.py     dependency-free scoring harness
tasks/task_0001/
    task.md                   human-readable statement of the task
    prompt.md                 ready-to-send model prompt
    input.json                structured evidence + chart of accounts
    expected_answer.json      graded answer + rubric  (do not show the model)
...
tasks/task_0118/

Identifiers run task_0001 to task_0118 with no gaps, and 118 task directories ship. Pin a dataset revision when you publish a result, so the run is reproducible against exactly these files.

Task format

Each input.json wraps its evidence in an input object, alongside task metadata:

Top-level key	Meaning
input	the public evidence, described in the table below
requiredOutput	the answer shape the model must return
taskType	crypto_accounting_full_entry for every task
organizationId	which organization's ledger and chart the task comes from
categoryAccountSolvability	admission label: the deciding account is reachable from the visible evidence. Evaluator metadata, not rendered into prompt.md
benchmark, task_id	identity of the benchmark task

The evidence fields below are therefore read at input.json -> input -> field, for example input.amounts.grossQuantity. Optional fields are absent rather than null when the source record does not resolve them.

input.input holds the public evidence:

Field	Meaning
organizationName	the organization that recorded the transaction (synthetic)
transactionType	the label the source application displays to the accountant. Open vocabulary, may be absent or UNKNOWN, and is not a reliable guide to the treatment
transactionDate	date and time, minute precision
transactionGroupId	identifies the on-chain action. Records sharing a group id came from one transaction
flowDirection	INFLOW (the source received) or OUTFLOW (the source sent)
assetType, chain	synthetic asset ticker and chain
amounts	grossQuantity / netQuantity / feeQuantity in asset units at full precision; grossValueBase / netValueBase / feeValueBase in currency at 2 decimal places; assetUnitPrice; quantityDecimalPlaces
fromAddress, toAddress	the two addresses on the transaction
source	the organization's own wallet or exchange account: name, walletType, chain, sourceType, isStakingAccountWallet, legalEntity
counterparty	the other side as the organization's records resolve it, with legalEntity, isZeroAddress and smartContractMetadata where they resolve
externalSource	the organization's own label for the other side
contractData, functionData, meta	contract, function called, token metadata
relatedTransactions	the organization's other records in the same transaction group
recurrenceProfile	factual summary of similar prior receipts into this wallet
taxLotEvidence	the cost-basis subledger rows: lotsCreated, lotsRelieved, methodology, proceedsBase
chartOfAccounts	the organization's complete ledger. The only accounts you may post to

prompt.md renders exactly the same content as a model prompt, with the reasoning guidance the benchmark uses.

Expected output

A model must return one JSON object:

{
  "journalEntry": {
    "lines": [
      {
        "ledgerAccountName": "<exact ledgerAccountName from the supplied chart of accounts>",
        "drCr": "Debit | Credit",
        "amountBase": "<decimal string, exactly 2 decimal places>",
        "currency": "<the task's base currency, from amounts.currency>"
      }
    ]
  },
  "assetQuantity": "<the transaction's asset quantity, full precision, as a decimal string>"
}

Rules the grader assumes:

• include all and only the lines the recorded treatment affects, meaning the wallet/asset line and every non-wallet treatment line the evidence supports;
• copy ledgerAccountName exactly as it appears in the chart, including the leading account number and separator;
• amountBase is a base-currency amount with exactly two decimal places;
• currency is the task's own base currency, read from amounts.currency. The set uses 2 base currencies, so it is not USD on every task;
• assetQuantity is not rounded;
• total debits must equal total credits per currency;
• line order does not matter;
• relatedTransactions are context, not additional accounting targets.

expected_answer.json adds grading metadata: keyLineAccounts (the deciding non-wallet account, which is the hard half of the task), realizedGainLoss, entryShape, tags, a plain-language explanation, reasoningEvidence (which signals in the evidence support the answer), and the task's rubric. Full schema in schema/expected_answer.schema.json.

Evaluation

Each task carries a frozen, task-specific rubric: 6 binary criteria with weights that sum to 1.0, fixed by the task's accounting family. Families group tasks by the rubric used to grade them, and they partition the set:

Rubric family	Tasks
TRANSFER	37
INCOME_EXPENSE	27
INTERCOMPANY	21
SWAP	16
FEE	12
REALIZED_GAIN_LOSS	5

The family field labels the realized gain/loss tasks REALIZED_GAIN_LOSS_A (3 tasks) and REALIZED_GAIN_LOSS_B (2 tasks). Both variants carry the same 6 criteria and the same weights, so they score as one family.

The paper reports three metrics, and this card is their public definition of record.

Metric	Definition
Mean Score	average rubric score over every expected attempt. Missing and failed attempts stay in the denominator with score zero. This is the primary metric
Best@k	average of each task's best rubric score over k attempts. An oracle-style capability ceiling rather than a reliability figure
Pass@k	share of tasks with at least one attempt that earns the full 100% rubric score and clears every required gate, both on the same attempt

Partial credit never qualifies for a pass, so 0.99 is not a pass, and a perfect rubric score that trips a required gate is not a pass either. An attempt that returns an unbalanced entry, an unparseable response, a rounded asset quantity, or the wrong currency does not pass. The paper defines 7 required gates, 6 of them deterministic and computed independently of the judge.

Everything else the scorer reports is a diagnostic rather than a reported metric: normalized complete-entry equality, deciding-account and wallet-account accuracy over keyLineAccounts, and the amount, Dr/Cr, quantity and balance components. The stored passThreshold of 0.85 in each rubric is likewise an attempt-level validation diagnostic and is not the Pass@k rule.

The upstream benchmark scores rubric criteria with an LLM judge and sums the weights locally. This dataset ships examples/run_benchmark.py, which computes the same weighted structure deterministically: it decides each criterion from account, side and amount equality rather than by judgement. It is a lower bound rather than an identical reimplementation, because a judge can credit a correct treatment expressed through a different but defensible account and the deterministic scorer cannot. Report which scorer you used.

examples/run_benchmark.py is the public implementation of that deterministic structure, and an internal implementation of the same structure runs beside the judge. The two are not independent claims: both are held to the same self-test, scoring the expected answers and requiring 1.0, so a normalization defect surfaces as a self-test failure rather than as a quietly different leaderboard.

Reported results

The paper evaluates 12 models over 3 independent attempts per task, which is 4,248 trajectories. The best Mean Score is 77.43% and the best Pass@3 is 56.78%. On best-of-3 deterministic diagnostics macro-averaged across the 12 models, asset quantity accuracy is 100.0% and base-amount agreement 97.8%, while deciding-account accuracy is 56.3%. The errors concentrate in account selection and entry composition. Of 4,248 attempts, 2,423 fail the full-rubric-and-gate requirement. These failures comprise 2,328 wrong-or-missing-account cases (96.1%), 84 direction cases (3.5%), and 11 extra-posting/amount cases (0.5%). Each failed attempt is counted once, with account failures taking precedence; underlying error signals can overlap.

Scoring a model

Record the revision of this dataset when you publish a result, so the run is reproducible against exactly these files.

# 1. self-test the scorer (expected answers must score 1.0)
python examples/run_benchmark.py --tasks tasks --out selftest.json

# 2. score a model: the command receives prompt.md on stdin, prints JSON on stdout
python examples/run_benchmark.py \
    --tasks tasks --attempts 3 \
    --model-command 'my-model-cli --stdin' \
    --out results.json

Or drive it yourself: for each tasks/task_NNNN/, send prompt.md to the model, parse the JSON it returns, compare against expected_answer.json, and aggregate. Nothing outside this directory is needed, and no credentials, network access or services are involved.

What the tasks cover

Grouped by the treatment their reference entry records, the tasks cover transfers, income and expense events, intercompany transfers among the 20 legal entities in the corpus, swaps, fee events, and disposals that relieve a tax lot and book the resulting realized gain or loss.

23 tasks are exchange-sourced rather than on-chain. They record realized trading gains and losses, funding income received, exchange trading fees, and 1 loan drawdown. No single trading account absorbs them: the correct account depends on the exchange, on the internal trading strategy the flow belongs to, and on whether value entered or left the account.

The evidence available across the set:

Property	Count
non-zero reference lines in total	246
inflows / outflows	55 / 63
tasks with created tax lots	17
tasks with relieved tax lots	21
tasks with tax-lot evidence of either kind	38
tasks with related same-hash records	60
tasks with prior-receipt history for the recurring transaction pattern	118
tasks with a realized gain/loss line	5
distinct synthetic assets	21
distinct synthetic chains	10, plus an exchange-only context
base currencies	2

manifest.json carries the full machine-readable composition, including the task identifier list, the asset and chain vocabularies, and per-file checksums.

Asset mix

Asset identity is synthetic, but asset class is preserved, because the class is what the accounting turns on. 67 tasks move an asset recorded at or close to par against the base currency, 6 of them a vault-bridge token representing an asset custodied on another chain. 3 move a share in a tokenized treasury fund, another 3 involve wrapped or liquid-staked positions, and 14 sit on the UTXO chain brint or the non-EVM staking chain oskil.

Ticker prefixes are meaningful and consistent: st is a liquid-staking receipt, w is wrapped, br is bridged, and gv is a vault share.

Limitations

• This is an accounting-reasoning benchmark, not a market, trading or price-prediction benchmark, and not a test of what the correct accounting treatment is in the abstract. It measures reproduction of a recorded treatment.
• The public dataset is transformed. Amounts, quantities, prices, dates, identifiers, names and asset/chain identities are synthetic, while generic accounting terminology and some public categorical labels, such as the exchange enum, are published as recorded. Do not treat any record as a factual statement about a real organization, transaction, person or counterparty, and do not attempt to match records against public chain data.
• Expected answers reflect one set of accounting conventions, those of the organizations whose ledgers the tasks derive from. A different but defensible treatment scores as wrong. That is deliberate: the task is reproduction.
• Aggregate scores characterize this evaluation population and are not a uniform sample of crypto accounting.
• Task difficulty is not labelled at a useful grain. Some tasks are decidable from a single strong signal, such as a counterparty label that effectively names the account, and others require combining several. The dataset does not tell you which is which. categoryAccountSolvability carries the single value inferable_from_visible_evidence on all 118 tasks, because reaching the deciding account from visible evidence was an admission requirement rather than a property that varies. Treat it as a guarantee about the dataset, not as a difficulty label.
• Answers are graded by account name, so an equally valid account under a different name in the same chart scores as wrong.
• The deterministic scorer shipped here is a lower bound on a judge-based score.

Citation

The paper is available at https://arxiv.org/abs/2609.14811. Cite the paper and the dataset:

Kareem Khattab, Omar Khattab, and Mohamed Ibrahem.
Crypto Accounting Bench: Evaluating Frontier and Open-Weight Models on
Crypto-Asset Accounting Tasks. Entendre Finance, September 2026. arXiv:2609.14811.

@misc{crypto_accounting_bench_2026,
  title        = {Crypto Accounting Bench: Evaluating Frontier and Open-Weight
                  Models on Crypto-Asset Accounting Tasks},
  author       = {Khattab, Kareem and Khattab, Omar and Ibrahem, Mohamed},
  year         = {2026},
  month        = sep,
  institution  = {Entendre Finance},
  note         = {Public benchmark dataset and evaluation set},
  howpublished = {\url{https://huggingface.co/datasets/Entendre/Crypto-Accounting-Bench}}
}

Reproductions should record the Hugging Face dataset revision they ran against.

State the scorer you used when reporting a result, for example: "Crypto Accounting Bench, public deterministic lower-bound scorer".