Datasets:

OpenCoven
/

fable-forge-10k

license: mit
task_categories:
  - text-generation
  - text2text-generation
language:
  - en
tags:
  - narrative-reasoning
  - character-consistency
  - recurrent-depth-transformer
  - story-generation
  - synthetic
  - opencoven
size_categories:
  - 10K<n<100K

FableForge — Narrative Reasoning Dataset with Recurrence-Depth Annotations

The first narrative dataset designed around recurrence depth requirements.

Every example carries a suggested_n_loops field with a theoretically grounded basis — derived from the structural complexity of the task, not a heuristic label or emergent property.

Background

Standard narrative datasets treat reasoning depth as an emergent property. FableForge is different: it annotates how much computation each task structurally requires, making it suitable for training Recurrent-Depth Transformers (RDTs) where loop count is a controllable hyperparameter at inference time.

Task Types

`character_trace`

Track a named character's state (location, emotion, companions) across N scene transitions.

Recurrence requirement: loops = f(n_characters × n_scenes)

More characters over more scenes → more recurrence needed to maintain entity state without drift.

`coherence_challenge`

Detect and correct a single planted narrative inconsistency.

Recurrence requirement: loops = f(inconsistency_type)

Six inconsistency types, ordered by cognitive depth:

Type	Loops	Why
`name_drift`	4	Surface pattern match
`location_contradiction`	8	Spatial reasoning
`object_continuity`	8	Object state tracking
`timeline_error`	16	Temporal ordering
`relationship_error`	16	Social graph recall
`trait_reversal`	32	Character psychology

`narrative_completion`

Generate a story continuation that satisfies N explicit constraints simultaneously.

Recurrence requirement: loops = f(n_characters × n_constraints)

Dataset Fields

Field	Type	Description
`id`	string	Unique stable identifier
`task_type`	string	`character_trace` / `coherence_challenge` / `narrative_completion`
`genre`	string	`fantasy` or `contemporary`
`complexity_score`	float	0–1, derived from task structure
`suggested_n_loops`	int	4 / 8 / 16 / 32 — recurrence target
`narrative_mode`	string	`action` / `dialogue` / `exposition`
`fable_memory_required`	bool	Whether FableMemory injection is needed
`coherence_probe_targets`	list[str]	Character names to monitor
`messages`	list	`[{"role": "user", "content": ...}, {"role": "assistant", "content": ...}]`
`source`	string	`fable_forge_v1`
`constraint_count`	int	Number of simultaneous constraints
`n_characters`	int	Characters in the task
`n_scenes`	int	Scenes spanned

Distribution (10k sample)

~40% character_trace, ~30% coherence_challenge, ~30% narrative_completion
~83% require FableMemory injection
Loop distribution: ~12% dialogue (8), ~37% exposition (16), ~51% deep (32)
Genres: ~50% fantasy, ~50% contemporary
Fully deterministic: seed=42

Usage

from datasets import load_dataset

ds = load_dataset("OpenCoven/fable-forge-10k", split="train")
print(ds[0].keys())
# dict_keys(['id', 'task_type', 'genre', 'complexity_score', 'suggested_n_loops',
#            'narrative_mode', 'fable_memory_required', 'coherence_probe_targets',
#            'messages', 'source', 'constraint_count', 'n_characters', 'n_scenes'])

# Filter by depth tier
hard = ds.filter(lambda x: x["suggested_n_loops"] == 32)
print(f"{len(hard):,} examples require maximum recurrence depth")

# Use with OpenFable NarrativeDepthController
from open_fable.depth import NarrativeDepthController
ndc = NarrativeDepthController()
for ex in ds.select(range(5)):
    loops = ndc.get_n_loops(ex["narrative_mode"])
    print(f"{ex['task_type']:25s} suggested={ex['suggested_n_loops']:2d}  ndc={loops}")

Generating More Data

FableForge is deterministic and open-source. Generate at any scale:

git clone https://github.com/OpenCoven/open-fable
cd open-fable
pip install -e .
python -m open_fable.data.fable_forge --count 100000 --seed 99 --output data/fable_forge_100k.jsonl

Two-Stage Training Pipeline

This dataset is Stage 2 of OpenFable's training pipeline:

Stage 1: WithinUsAI/claude_mythos_distilled_25k bridged via MythosBridge — general deep reasoning
Stage 2: FableForge — narrative-specific reasoning with loop-depth annotations

Citation

@misc{openfable2026fableforge,
  title   = {{FableForge}: A Synthetic Narrative Dataset with Recurrence-Depth Annotations},
  author  = {OpenCoven},
  year    = {2026},
  url     = {https://github.com/OpenCoven/open-fable},
  note    = {First dataset designed around recurrence depth requirements for
             narrative reasoning in Recurrent-Depth Transformer architectures.}
}

License

MIT — see LICENSE