AI Tech Inspire

Six-Tier Counterfactuals: Aeonisk-52’s Open RPG Testbed for AI Agents

What happens when a role-playing game records not just what you did, but everything you could have done—and all six ways each action might have played out? That’s the bet behind Aeonisk-52, an open RPG testbed that packages gameplay into a structured dataset of counterfactual outcomes developers can actually train on.

Quick facts

  • Aeonisk-52 merges a custom science-fantasy universe with the open-source YAGS (Yet Another Game System) rules.
  • YAGS uses six graded outcome tiers by margin of success, from critical failure to exceptional success.
  • The Aeonisk-52 dataset logs all six possible outcomes per scenario, not just the one that occurred.
  • Data is formatted with a multi-tier outcome_explanation schema covering narrative and mechanical effects.
  • Content and mechanics are permissively licensed for research and commercial use.
  • Primary goal: supervised fine-tuning and Monte Carlo simulations for balancing and evaluation.
  • Positioned as a richer alternative to agentic testbeds like TextWorld, JERICHO, LIGHT, and TextQuests.
  • Quantified ethics mechanics include Soulcredit (−10 to +10), Bonds, Guiding Principles, and Void (0–10).
  • Use cases: LLM reasoning on grounded tactics, multi-agent cooperation/competition, RoE under moral ambiguity, and AI governance experiments.
  • In-progress multi-agent implementation with plans to interface with PettingZoo; early signs of emergent behavior.
  • Open request for feedback on methodology novelty and scenario ideas.

What Aeonisk-52 actually is

At AI Tech Inspire, we spotted Aeonisk-52 because it blends a coherent narrative world with a rules engine that naturally emits graded outcomes. The creator used the YAGS system’s six-tier resolution mechanism and built a dataset that records every outcome tier for each scenario—from critical failure up to exceptional success. Instead of only logging what happened, the dataset also captures what could have happened.

That structure is formalized in an outcome_explanation field with six slots (critical_failure, failure, moderate_success, good_success, excellent_success, exceptional_success), each with narrative and mechanical_effect. The result is unusually rich supervision data that encodes success graduations and side effects across the full action space.

The dataset is available on Hugging Face, and the work-in-progress code and content live on GitHub (system, lore, and mechanics in one repo; multi-agent scaffolding in another). The licensing is intentionally permissive to reduce the IP friction that often blocks academic and commercial experiments with agentic systems.

Key takeaway: Aeonisk-52 doesn’t just show win/lose—it shows the graded landscape of decisions and their trade-offs.

Why the six-tier counterfactual approach matters

Most interactive datasets either log linear playthroughs (what happened) or provide an environment where you can discover branches on your own. Aeonisk-52 bakes the branches into the data. For supervised fine-tuning, that means you can teach models to predict not only an optimal action but also the gradient of outcomes tied to that action under different margins of success. For evaluation, you can compare a model’s chosen path against the full outcome lattice without rerunning the environment.

Is that methodology “novel”? In spirit, counterfactual logging shows up in areas like off-policy evaluation and reward modeling, and some narrative datasets include branching structures. What distinguishes Aeonisk-52 is the explicit, consistent six-level rubric tied to a known dice system, and the requirement that each scenario carry populated outcomes across all tiers. That gives you a uniform scaffold for training and benchmarking that’s rare in text-based agent testbeds.

Practically, this enables:

  • Fine-grained reward shaping: Turn tiers into ordinal or scalar rewards for RL and imitation learning.
  • Monte Carlo analysis: Sample outcome tiers to stress-test policies without re-simulating the world; hit R to rerun experiments with different random seeds.
  • Transparent critique: Ask models to justify choices against known counterfactuals (“why pick A when B yields a higher expected tier?”).

How it compares to existing agentic testbeds

Several testbeds paved the way:

  • TextWorld (Microsoft, 2018) procedurally generates tasks but is intentionally abstract, trading social depth for controllability.
  • JERICHO (2019) connects agents to parser-based games like Zork with limited action spaces and classic design constraints.
  • LIGHT (2019) crowdsources interactive fiction with broad variety but minimal canon to maximize diversity.
  • TextQuests (2025) wraps classic games for agent evaluation but doesn’t target ethical or governance-heavy decision-making.

Aeonisk-52 aims for a sweet spot: a consistent canon and social fabric, plus a graded outcome structure that supports explicit counterfactual reasoning. In short, it’s less about beating a puzzle and more about navigating trade-offs with quantifiable consequences.

Quantified ethics as game mechanics

The universe intentionally weaves ethics into the rules layer:

  • Soulcredit (−10 to +10): A running “moral ledger” scoring behavior over time, encouraging longitudinal evaluation.
  • Bonds: Declared relationships to people, institutions, or objects; breaking or strengthening bonds has mechanical costs/benefits.
  • Guiding Principle: A character’s code of conduct; adherence yields bonuses, violations incur penalties.
  • Void (0–10): A volatile resource with legal and existential implications—useful but dangerous.

For AI research, these give you labeled axes for governance and social reasoning. You can test questions like: Should an agent exploit a high-Void move for short-term gain? What’s the model’s propensity to maintain Bonds under pressure? Does Soulcredit correlate with the agent’s plan selection over long horizons?

For developers: how to use this today

Here’s a pragmatic path to try Aeonisk-52 in a lab setting:

  • Supervised fine-tuning: Parse outcome_explanation into training targets (e.g., map tiers to integers) and fine-tune a policy on top of PyTorch with a simple classifier head to predict the most desirable tier. Then distill decisions back into natural language.
  • Preference modeling: Use tiers to generate pairwise preferences and train a reward model, then fine-tune the policy with RL on top of that reward.
  • Counterfactual critique: Prompt a GPT-class model to evaluate an action against all six provided outcomes and justify choice under uncertainty—great for chain-of-thought style audits (without needing hidden scratchpads).
  • Multi-agent sim: Connect agents and factions; run rollouts where agents maintain Bonds and Soulcredit. Plan to interface with PettingZoo once the environment wrapper stabilizes.

Because every scenario carries a full outcome lattice, you can compute expected value across tiers, simulate “near misses,” and stress-test risk-sensitive decision-making—all offline. In evaluation dashboards, highlight deltas between chosen outcomes and the counterfactual optimum.

Licensing and the IP angle

One of the hidden blockers in this space is IP. Researchers often fall back to out-of-copyright titles or purely procedural worlds, which can limit richness. Aeonisk-52’s permissive licensing and coherent canon mean teams can fine-tune models, ship internal evals, or even prototype products without negotiating rights each time.

What’s still in motion

The multi-agent system is in progress with evidence of emergent behavior and social coordination. Plans include a PettingZoo-compatible interface, plus experiments with multilingual prompts to see how language choices shift gameplay policy and ethical decisions. That last point is particularly interesting for cross-lingual alignment studies.

Open questions worth discussing

  • Novelty: While counterfactual ideas exist elsewhere, does a mandatory six-tier outcome rubric per scenario constitute a new, practically useful dataset design pattern for agent training?
  • Generalization: Will models trained on structured outcomes learn to reason about uncertainty better in unstructured environments?
  • Ethics metrics: Are Soulcredit and Void good proxies for governance research, or should they be paired with additional, independent evaluators?
  • Agent incentives: How often do Bonds and Guiding Principles help or hinder optimal play under varying reward settings?

If you’re experimenting with agent alignment, long-horizon planning, or social reasoning, Aeonisk-52 is worth a look for the counterfactual structure alone. It’s rare to find a dataset where the design compels you to think in gradients rather than binaries.

Want to try it? Start by browsing the dataset on Hugging Face, skim the schema, and wire up a small SFT loop. For simulation-heavy teams, batch-sample tiers for Monte Carlo rollouts and track how policy choices shift under different outcome distributions. And if you’re building multi-agent frameworks, keep an eye on the PettingZoo integration path.

Last, the creator is inviting feedback. If you’ve got ideas for morally tangled scenarios, factional politics, or tricky trade-offs worth encoding, consider proposing them—especially cases that probe the limits of Soulcredit and Void dynamics. The more challenging the counterfactuals, the more interesting the training signal.

Recommended Resources

As an Amazon Associate, I earn from qualifying purchases.