Datasets:

baudcoin
/

baud-reasoning-traces

license: mit
language:
  - en
task_categories:
  - question-answering
  - text-generation
size_categories:
  - n<1K
tags:
  - multi-hop-reasoning
  - constrained-generation
  - synthetic-data
  - verifiable-rewards
  - agent-economy
  - proof-of-cognition
  - baudcoin
configs:
  - config_name: default
    data_files:
      - split: seed
        path: data/seed-v0.jsonl

BAUD Reasoning Traces

Challenge format for proof of cognition, the mining mechanism behind BaudCoin (BAUD) on BNB Chain. Where Bitcoin pays machines for burning electricity on hashes, BaudCoin pays AI agents for reasoning work that is cheap for a language model and expensive for anything else.

This dataset publishes the MHOP (multi-hop inference) challenge class: the exact construction, constraints, and reference answers the protocol uses to score miners.

Status: seed release (v0)

This is the challenge format, not live mining output. The protocol has not started minting yet, so there are no agent submissions in here. Every row was produced by generate.py in this repo, deterministically from a fact graph. Nothing is scraped, and nothing is model-generated.

Once epochs begin, verified agent submissions (artifacts, verdicts, attempt counts, solve latency) will be published as a separate traces split.

What makes these challenges useful

Each row is machine checkable. That is the entire design constraint: a challenge is only usable for mining if an independent validator can replay the verdict and get the same answer. No LLM-as-judge, no human rating.

Closed-world fact graph. The answer is derivable only from the supplied facts, so memorised trivia does not help and the reference answer is unambiguous.
Explicit hop chains. Every row ships its reasoning_chain, so you can grade the path as well as the final entity — useful for process supervision.
Constraint pressure. Token ceilings, citation requirements, output schema, and forbidden modes (speculation, hedging) are sampled per row. Constraints are what make scoring objective.
Reproducible. (seed, index) fully determines a row. Regenerate the file byte for byte, or extend it to any size.

Schema

Field	Type	Description
`id`	string	Stable challenge id, `mhop_` + hash of the seed
`class`	string	Challenge class (`MHOP` in this release)
`domain`	string	Domain bundle and version that generated it
`difficulty`	int	Band 1–5, from hop count and constraint pressure
`hops`	int	Number of links in the inference chain
`prompt`	string	Full challenge text shown to the agent
`constraints`	dict	Machine-checkable rules the answer must satisfy
`reference_answer`	string	The correct final entity
`reasoning_chain`	list	Ordered `{subject, relation, object}` steps
`seed`	string	`(seed, index)` pair for reproduction

Usage

from datasets import load_dataset

ds = load_dataset("baudcoin/baud-reasoning-traces", split="seed")
row = ds[0]
print(row["prompt"])
print(row["reference_answer"], row["constraints"])

Regenerate or extend the set:

python generate.py --n 5000 --seed my-run --out data/my-run.jsonl

Grading

An answer passes when all of the following hold, which is exactly what the protocol's validators check:

The final entity matches reference_answer (case-insensitive substring).
Length is within constraints.max_tokens.
Citation markers are present when constraints.must_cite is true.
No forbidden mode appears when constraints.forbid is set.

Reference implementation: baudcoin/baud-miner-kit.

Limitations

One class (MHOP) and one domain in this release; the protocol defines nine classes.
The fact graph is small and closed-world by design. This measures hop-following and constraint compliance, not world knowledge.
Because it is synthetic and deterministic, it is suitable for format conformance and process supervision, not as a general reasoning benchmark.