The Binding — Enter the books you love

The Binding

Enter the books you love.

The Binding — Project Status Report

Updated: July 16, 2026 02:00 UTC • New: dice test suite (207 tests), server error handling fix, web app expanded to 70KB

74%
Phase 1 Core Engine
66%
Infrastructure
57%
Beta Readiness
HELD
Telegram Deploy

Phase 1 — Core Engine

Delivery ItemStatusCompletionNotes
AI DM Service (LLM orchestration + streaming) ✅ Built
90%
4 modules (1,191 lines): context-manager, dm-service (18.5KB), llm-provider (21.8KB), prompts. Mock/dev error handling improved (commit 1f35464).
Rule Engine (D&D 5e core) ✅ Built
90%
7 modules: combat, dice, stats, classes, races, character-sheet. Full 5e SRD coverage. Has test suite.
Dice Service ⚠️ Partial
75%
4 modules (899 lines): types, random, service, index. Comprehensive test suite added (207 tests, commit 73f04b1). Dice roller UI built (dice-roller.js, 441 lines). Still missing video animations.
Character Creation & Management ✅ Built
85%
Model, service, portrait gen. Narrative onboarding flow. Portrait gen needs image API wired up.
Scene Engine + Continuity Validator ✅ Built
80%
Exit pressure ramps, completion tracking, 4-action system per spec.
Web App (PWA) ⚠️ Partial
65%
Vanilla HTML frontend (index.html 70.9KB + create.html 22KB). Dice roller UI + 3D physics (dice-roller.js 18.5KB). PWA manifest + service worker done. Not React/framework.
Adventure Content (3 books) ✅ Built
90%
Dracula (25 scenes), Frankenstein (25 scenes), Sherlock Holmes (25 scenes). Full narrative bug hunt completed — 101 bugs found, 75+ fixed across all 75 scenes. 4 review files on file. Commit ffacd7d.
TTS Voice Service 🔨 Building
55%
tts-service.js (408 lines) + index.js (40 lines). TTS service code built. Needs API key and end-to-end test.
Session Management + Message Router ✅ Built
90%
Persistence + message routing working.
Auth + API Server ✅ Built
92%
Fastify server (952 lines), token auth, SSE streaming, WebSocket support. Error responses improved for dev/mock mode (commit 1f35464).
Phase 1 + Phase 2 Test Suites ✅ Built
85%
3 test suites (50KB total): phase1.test.js (19KB), phase2.test.js (12KB), dice.test.js (19KB, 207 tests). Commit 73f04b1.
Coin/XP Scoring Engine 🔨 Building
40%
coin-engine module (225 lines). Core scoring logic built. Needs AI DM creativity assessment integration.
Combat Manager ✅ Built
70%
combat-manager.js (438 lines). Initiative, multi-foe encounters, action economy. Integrated with rule engine.
Dynamic Difficulty 🔨 Building
50%
dynamic-difficulty.js (219 lines). Rubber-band scaling logic built. Needs tuning with playtest data.
Inventory System 🔨 Building
50%
inventory.js (240 lines). Item tracking, equipment slots. Needs Shoppe marketplace integration.

Infrastructure & Deployment

Delivery ItemStatusCompletionNotes
Hosting — Render.com ✅ Configured
90%
render.yaml + Dockerfile ready. Deploy pending.
Telegram Bot ⏸️ HELD
100%
Bot built (9KB). READY to deploy. HELD — Lawman to greenlight beta roll-out.
GitHub Repository ✅ Ready
95%
PAT configured. Code ready to push.
Image Generation Pipeline ❌ Not Started
0%
Image directory empty. Needs xAI Grok Imagine or equivalent integration.
Voice / TTS Infrastructure 🔨 Building
45%
TTS service code built (tts-service.js, 408 lines). Needs provider API key and end-to-end integration test.

Beta Readiness

Delivery ItemStatusCompletionNotes
End-to-End Smoke Test 🔨 In Progress
35%
Partial: signup → NDA → questionnaire → character creation → Dracula Scene 1 all functional. Inventory init fixed (commit 475bc20). Error handling improved (commit 1f35464). Remaining: full adventure playthroughs, session rejoin, spectator mode.
Narrative Bug Hunting ✅ Complete
100%
Full audit of all 3 adventures (75 scenes, 15 acts). 101 bugs found: 29 HIGH, 31 MEDIUM fixed. Exit labels, NPC tracking, item tracking, discovery texts, banned keywords all reviewed. 4 review files (787 lines). Commit ffacd7d.
Beta Signup + Token System ✅ Built
90%
beta-signups.json + beta-tokens.json + auth/token-store.js all in place.
Telegram Beta Deployment ⏸️ HELD
Waiting for Lawman's go-ahead. Ask him when ready.

What's NOT Built Yet

Three empty directories remain between "code exists" and "playable beta":

  • src/image/ — No image generation pipeline. Needs Grok Imagine or equivalent.
  • src/frontend/ — Empty. Current web app is vanilla HTML, not the spec'd React framework.
  • src/blockchain/ — Empty placeholder. Phase 3 blockchain integration (NFTs, $BINDING token).
  • data/dice-videos/ — Empty. No dice-roll animation videos recorded.

Note: src/voice/ is no longer empty — TTS service code has been built (448 lines). Needs API key to activate.

Recommended Next Steps (Priority Order)

  1. Smoke test the full flow — Walk through signup → character creation → play through an adventure as one continuous journey. Fix breaks.
  2. Narrative bug hunt — Play through Dracula/Frankenstein/Holmes scenes proactively to flush out logic, continuity, and pacing bugs. ✅ Done — 101 bugs found, 75+ fixed. Commit ffacd7d.
  3. Wire up TTS API key — Voice service code is built. Add provider API key (ElevenLabs or OpenAI TTS) and test end-to-end.
  4. Deploy Telegram beta — Once steps 1–3 are solid, greenlight the Telegram bot deployment.

Executive Summary

The Binding is an AI-powered platform that transforms any book into a live, playable role-playing experience. Users select a book (Dracula, Treasure Island, Gone with the Wind — anything), create a character, and play through the story with an AI Dungeon Master that narrates, adjudicates rules, generates scene images, and speaks in character.

The platform runs cross-platform (mobile, tablet, desktop) and integrates deeply with the Paxeer blockchain for character ownership, a marketplace economy, and community-driven content creation.

The core insight: Every book ever written is an unplayed adventure. The Binding makes them playable.

What Makes The Binding Different

Why This Matters for Paxeer

The Binding is designed to be a flagship consumer application on the Paxeer network — the kind of product that brings mainstream users onto the chain without them needing to understand blockchain mechanics.

BenefitDetails
New wallet creationEvery player who earns $BINDING needs a Paxeer wallet. Projected: 10,000–50,000 new wallets in Year 1.
On-chain activityCharacter NFTs, $BINDING token, achievement badges, Shoppe marketplace trades, seasonal items — all on Paxeer. Consistent daily on-chain volume.
Gas fee revenueNFT minting, $BINDING conversions, marketplace trades, metadata updates generate gas. Batched transactions keep it efficient.
USDC/PAX liquidityUsers purchase with PAX or swap to USDC for marketplace transactions. Drives DEX volume.
Ecosystem credibilityA polished, mainstream consumer app proves Paxeer can host production applications — not just DeFi.

Market Opportunity

SegmentSizeWhy They Care
Tabletop RPG players50M+ globallyAI DM available 24/7, no scheduling, infinite content, real coin rewards
Book readers / BookTok200M+ active“Play through your favorite book” — earn coins while you do it
Interactive fiction fans30M+ (growing 15% YoY)AI-driven, every choice matters, replayable, competitive leaderboards
Casual mobile gamers2B+ globallyLow barrier, narrative-driven, session-based, earn real value
Crypto/Web3 curious50M+ active walletsEarn $BINDING by playing, not buying. Meme coin with a real use case.

Competitive Landscape

ProductWhat They DoThe Binding’s Advantage
AI DungeonText-based AI adventureNo book content, no visuals, no voice, no rules engine, no blockchain, no coin economy, no replayability system
D&D BeyondDigital D&D toolsRequires a human DM and a group. No AI narrative. No coin rewards. No adaptive difficulty.
Choice of GamesInteractive fictionScripted, not AI-driven. No replayability. No real value earned from play.
Replika / Character.aiAI conversationNot gameified. No rules, no dice, no progression, no coins, no competition.

The Binding sits in white space — no existing product combines AI narration + game rules + visual generation + voice + book content + blockchain ownership + intelligence-rewarded coin economy + adaptive replayability + seasonal competition.

Revenue Model

Revenue StreamDescriptionModel
Adventurer’s LicenseOne-time unlock after 5-hour free trial$1.99
Guild Pass SubscriptionFull library, all voices, exclusive cosmetics$9.99/mo
Shoppe MarketplaceNFT item trading between playersPlatform fee on each trade
Seasonal CosmeticsLimited-edition items, dice sets, portraitsDirect purchase
Adventure Module SalesCreator-authored adventuresPurchase + creator royalties on resale
$BINDING Economy0.01% of all revenue feeds the $BINDING liquidity poolDrives token value for holders

Revenue Projections (Conservative)

MetricYear 1Year 2Year 3
Registered users50,000200,000750,000
Paid users (Adventurer’s License)20,00080,000300,000
Guild Pass subscribers5,00025,000100,000
Monthly recurring revenue$50,000$300,000$1,200,000
Shoppe marketplace + cosmetics$20K/mo$100K/mo$400K/mo
$BINDING pool contribution$1K/mo$5K/mo$20K/mo
Total annual revenue$840,000$4,800,000$19,200,000

Product Architecture

The User Experience

  1. User opens the app — a voice speaks: “You’re about to enter a world of monsters, magic, and choices that matter. But first… tell me your name.”
  2. Character creation through narrative dialogue — no forms. The AI DM asks personality questions and builds the character.
  3. User picks an adventure. The game calibrates difficulty to their level (invisible, narrative-driven).
  4. Every turn: AI narrates → 4 suggested actions + open text/voice field → user chooses → dice rolled → consequences → scene image → subtle coin notification if earned.
  5. Each chapter ends with a coin breakdown: “You earned 340/500 coins this chapter. Creative Problem Solving (+120), Investigation (+90)...”
  6. Adventure ends. Tier awarded: Bronze / Silver / Gold / Platinum. Play style summary shown.
  7. Coins can be converted to $BINDING at tier-weighted rates and sent to player’s Paxeer wallet.
  8. 5-hour free trial. Then $1.99 to continue. Subscription and marketplace layered on top.

Paxeer Integration

AssetContract TypeDetails
$BINDING TokenERC-20Platform meme coin. Only mintable through gameplay. Tier-weighted conversion from in-game coins.
Character NFTsERC-721 (dynamic)Stats, level, equipment, portrait, achievements, tier badges. Updates as character evolves.
Guild Pass NFTERC-721 (dynamic)Subscription token. Tiered: Adventurer → Hero → Legend → Mythic.
Shoppe MarketplaceCustomListings, purchases, royalties, escrow. NFT item trading between players.
Tier Badge NFTsERC-1155 (soulbound)Non-transferable. Earned per adventure per season. Displayed on profile.
Achievement BadgesERC-1155 (soulbound)Non-transferable. Earned through gameplay milestones.
Seasonal LeaderboardOn-chain + off-chain6-month seasons. Top performers earn bonus $BINDING + exclusive badges.
Adventure Module NFTsERC-1155Purchasable content. Creator royalties on resale (5%).
Dice Set NFTsERC-1155Collectible cosmetic dice. Limited seasonal drops.
Shoppe Item NFTsERC-721Found treasures. Cosmetic + gameplay bonus + tradeable. Seasonal scarcity.

Key Technical Decisions

  1. LLM is NOT the rule engine. AI generates narration. A separate deterministic system handles dice math, combat, stats, coin scoring.
  2. Coin scoring is deterministic + AI-judged. Base coins from game math (combat, exploration). Bonus coins from AI assessment of creativity and intelligence.
  3. Gameplay never blocked by blockchain. All on-chain operations are async via event queue.
  4. Context window management. Tiered context (hot/warm/cold/reference) for 50+ hour adventures.
  5. Voice and text parallel streams. Text sub-500ms. Voice sub-2s. Images load in background.
  6. Replayability is architectural. Three-layer model (curated backbone + procedural connective tissue + surface variation) with adaptive sub-plot generation that learns player style.

Why Now

  1. LLM technology is mature enough (GPT-4o, Claude 3.5)
  2. Voice synthesis is production-ready (ElevenLabs, OpenAI TTS)
  3. Image generation is fast and affordable at consumer scale
  4. Paxeer blockchain infrastructure is ready
  5. The market is hungry — AI Dungeon proved the concept but failed on quality
  6. Meme coins with real utility are the next wave — $BINDING earns its value through gameplay, not hype

Monetization Philosophy

The platform is designed around a “generous free, irresistible premium” philosophy. No paywalls. Players sign up free, get a 5-hour full-featured trial, then pay $1.99 to unlock permanently. A $9.99/mo Guild Pass subscription provides the full library, all voices, and exclusive cosmetics.

The coin and $BINDING economy creates a play-to-earn layer that doesn’t feel like crypto — players earn coins for playing well, convert them to $BINDING at tier-weighted rates, and spend them in The Shoppe. The only way to get $BINDING is to play. No ICO. No presale. No VC allocation. Just play.

Seasonal leaderboards, limited-edition Shoppe items, and tier badges create engagement loops that drive retention without predatory mechanics. All monetization layers are designed to feel like value, not gates.

Development Phases Summary

PhaseGoalTimelineTeam Size
Phase 1 — Core EngineOne playable adventure end-to-end with coin scoring4–5 months2–3 engineers
Phase 2 — Full Experience + Campaign ModeMulti-adventure, voice, monetization, Shoppe, multi-player D&D3–4 months3–5 people
Phase 3 — Blockchain & Competition$BINDING token, NFTs, marketplace, leaderboards, seasonal economy3–4 months4–5 people
Phase 4 — ScaleCreator tools, licensed IPs, advanced featuresOngoing (month 11+)5+
TOTAL TO FULL LAUNCH10–13 months2–6 people

Phase 1 — Core Engine (Months 1–4)

DeliverableEffortDetails
AI DM service (LLM orchestration + streaming)4–6 weeksContext management, 4-suggestion generation, scene narration, NPC dialogue, creative score assessment
Rule engine (D&D 5e core)3–4 weeksStandard + Story Mode. Combat, skill checks, saving throws, leveling. Rubber-band difficulty scaling.
Coin/XP scoring engine2–3 weeksIntelligence-weighted scoring, theoretical max per adventure, bell curve distribution, hybrid real-time + chapter-breakdown rewards
Dice service with animations2–3 weeks7 die types, 30+ videos, shake detection, fair random
Character creation & management2 weeksNarrative onboarding, stats, inventory, portrait, player profile tracking (play style)
Adventure engine (scene graph)3–4 weeksScene navigation, quest tracking, journal, save/load, curated backbone structure
Web app (PWA)3–4 weeksReact frontend, responsive, WebSocket real-time sync, coin/tier display
3 adventures: Dracula, Frankenstein, Holmes6–8 weeks75 curated scenes (25 each), NPC pools, encounters, Layer 1 backbone. Full narrative bug hunt — 101 bugs found, 75+ fixed. Commit ffacd7d.
Basic voice (1 DM voice)1 weekSingle TTS voice, text NPCs
PHASE 1 TOTAL18–24 weeks~4–6 months

Phase 1 Deliverable: Working PWA. User signs up, creates a character, plays through Dracula, Frankenstein, or Sherlock Holmes with AI DM, dice rolls, coin scoring, tier award, basic voice, and scene images. All 3 adventures have been narrative-audited end-to-end (101 bugs found and fixed). Player can see their coin breakdown and tier after each chapter.

Phase 2 — Full Experience + Campaign Mode (Months 5–8)

DeliverableEffortDetails
All 6 DM voices + NPC voice differentiation2–3 weeks8–10 preset voice profiles, persistent NPC assignments
Player voice input (STT)1 weekWeb Speech API + Whisper fallback
Image pipeline (pre-gen + real-time)3–4 weeksAdventure art, real-time scene images, caching
Replayability engine (Layer 2 + 3)3–4 weeksProcedural sub-plot generation, surface variation, adaptive player profiling
Quest Mode + Explorer Mode3–4 weeksStory rails vs. sandbox with narrative gravity
The Shoppe (basic)2–3 weeksItem display, treasure drops, in-game coin purchasing, inventory management
Adventure journal + session recap2 weeksAuto-generated journal, cinematic recap, play style summary
5-hour trial + $1.99 payment2 weeksClock mechanics, crypto/fiat payment
3 additional adventures (6 total)3–4 weeksTreasure Island, Odyssey, Time Machine (Sherlock Holmes already built in Phase 1)
Mobile wrappers (Capacitor)2 weeksiOS + Android, App Store prep
Multi-player session management2–3 weeksJoin codes, lobby, session rooms, player arrays (extends Phase 1 abstractions)
General-purpose AI DM mode3–4 weeksOpen-ended improvisation, on-the-fly encounters, world-building. Extends adventure-mode AI DM.
Monster stat blocks + initiative2 weeksData layer for monster stats, initiative tracker, multi-foe combat (extends rule engine)
DM whisper system1 weekPrivate messages to individual players (message router already supports targets)
Theater of the mind1–2 weeksVerbal spatial descriptions, no grid. Prompt engineering on existing AI DM.
Session persistence2 weeksSave/resume across sessions. World state already at session level from Phase 1.
PHASE 2 TOTAL12–18 weeks~3–5 months

Phase 3 — Blockchain & Competition (Months 8–11)

DeliverableEffortDetails
$BINDING ERC-20 token3–4 weeksToken contract, minting logic (gameplay-only mint source), tier-weighted conversion service, wallet integration
Seasonal leaderboard system3–4 weeks6-month seasons, leaderboard resets, seasonal coin budgets, top-performer bonus $BINDING distribution
Shoppe marketplace (full)4–5 weeksNFT item listings, purchases, royalties, escrow, seasonal item rotation, lifetime tier discounts
$BINDING liquidity pool1–2 weeksDEX integration on Paxeer, revenue-to-pool drip mechanism, deflationary curve implementation
Guild Pass subscription + NFT minting3–4 weeksDynamic NFT contract, tier progression
Character NFTs on Paxeer2–3 weeksERC-721, dynamic metadata, coin/tier data embedded
Tier badge + Achievement NFTs2 weeksERC-1155 soulbound. Per-adventure per-season tier badges.
Friend list + party multiplayer4–6 weeksReal-time shared sessions, party chat
15+ adventures totalOngoingContent pipeline scaling
PHASE 3 TOTAL16–22 weeks~4–5 months

Infrastructure Costs by Phase

PhaseMonthly CostNotes
Phase 1 (development)$200–500API calls for testing, dev hosting
Phase 2 (beta, ~1K users)$1,000–3,000LLM + image gen + TTS scaling
Phase 3 (launch, ~5K users)$4,000–9,000Full infrastructure + blockchain deployment + $BINDING liquidity seeding
Phase 4 (growth, 50K+ users)$15,000–40,000Auto-scaling, CDN, DEX liquidity
Total infrastructure to launch~$30K–$80KOver 9–12 months

Team Requirements

RolePhase 1Phase 2Phase 3
Full-stack engineer (lead)111
Full-stack engineer0–111
AI/ML engineer0–111
Blockchain engineer0–11
Designercontract11
Content/game designer0–10–11
TOTAL2–33–54–6

Paxeer On-Chain Requirements

ComponentContract TypePhase
$BINDING TokenERC-20 (gameplay-only mint)Phase 3
Character NFTsERC-721 (dynamic metadata)Phase 3
Guild Pass NFTERC-721 (dynamic, tiered)Phase 3
Shoppe MarketplaceCustom (listings, escrow, royalties, seasonal rotation)Phase 3
Tier Badge NFTsERC-1155 (soulbound, per-adventure per-season)Phase 3
Achievement BadgesERC-1155 (soulbound)Phase 3
Shoppe Item NFTsERC-721 (cosmetic + gameplay bonus + tradeable)Phase 3
Adventure Module NFTsERC-1155Phase 3
Dice Set NFTsERC-1155Phase 3
$BINDING Liquidity PoolDEX pair on PaxeerPhase 3
All gameplay + coin scoringOff-chain (events queue to blockchain async)Phase 1+

Summary

Time to full launch9–12 months
Infrastructure cost to launch~$30K–$80K
Team size at launch2–6 people
Year 1 projected revenue$840,000
Year 3 projected revenue$19,200,000
New Paxeer wallets (Year 1)10,000–50,000
$BINDING mint sourceGameplay only (no ICO, no presale, no airdrop)
Season length6 months with leaderboard reset
Adventures at launch15+

Game Design Decisions

Confirmed design decisions for The Binding's core gameplay systems. These represent the product vision as agreed between the founding team.

1. Coin & XP System

Every adventure has a theoretical maximum coin pool — a fixed number based on story length and difficulty. Coins are awarded based on how intelligently you play, not just whether you win.

Design ElementDecision
Scoring methodHybrid — real-time subtle notifications during play + full breakdown at end of each chapter
What earns coinsIntelligence-weighted: creativity, problem-solving, investigation, roleplay, combat efficiency
DistributionStandard bell curve — only 0.01% of players ever max out a single adventure
Theoretical maxFixed per adventure, based on story length + difficulty level
Post-chapter summary“You earned 340/500 coins. Creative Problem Solving (+120), Investigation (+90), Combat (+80), Roleplay (+50)”
The scoring rubric must be generous rather than stingy — better to reward too often than too rarely at launch. Players should understand what gets rewarded and learn to play better over time.

2. Tier System

TierRequirementExpected Rarity
BronzeComplete the adventure~95% of players
SilverEarn 60%+ of max coins~60% of players
GoldEarn 85%+ of max coins~15% of players
PlatinumEarn 95%+ of max coins AND finish in top 10% of completion time~1% of players

Key design note: Speed requirement applies ONLY to Platinum tier. Platinum means you played near-perfectly AND efficiently. That’s mastery — the screenshot people share, the badge that makes someone say “how did you do that?”

3. Universal Cross-Book Currency

Coins earned in any adventure are fungible — 1 Dracula coin = 1 Frankenstein coin = 1 Sherlock Holmes coin. Your lifetime balance carries across all adventures, The Shoppe, the meme coin exchange, and your player profile.

Tier-Weighted Conversion to $BINDING

Tier EarnedConversion RateExample: 1,000 coins becomes
Bronze1x1.00 $BINDING
Silver1.5x1.50 $BINDING
Gold2.5x2.50 $BINDING
Platinum5x5.00 $BINDING

Lifetime Tier Discounts at The Shoppe

Lifetime Average TierShoppe Discount
Bronze averageFull price
Silver average10% off
Gold average25% off
Platinum average40% off + access to exclusive items
The tier-weighted conversion kills the exploit where someone creates 50 accounts and farms the easiest adventure on the lowest difficulty. Bronze conversion at 1x means that strategy generates almost nothing. The system rewards quality over quantity.

4. $BINDING Meme Coin & Seasonal Economy

$BINDING is the platform’s meme coin. The only way to earn $BINDING is to play well in The Binding. No ICO. No presale. No airdrop farming. No VC allocation.

Season Structure (6-Month Seasons)

ComponentWhat Happens
New Adventures2–3 new books drop per season. New stories = new coin pools = fresh leaderboard
Season LeaderboardResets every 6 months. Top performers get bonus $BINDING + exclusive NFT badges
Coin Pool BudgetEach season has a defined minting budget. Controls inflation.
The ShoppeSeasonal items rotate in and out. Creates scarcity and urgency.
Legacy BonusPlayers from earlier seasons get a permanent +% on all future conversions. Loyalty rewarded.

Era Structure

EraSeasonsThemeEconomy
Era 1: FoundersS1–S5Build core community, 5 adventures, prove the modelSmall coin pool, high value per coin. Best Legacy Bonus for early players
Era 2: GrowthS6–S15Scale to thousands of players, 20+ adventures, marketplace opensGrowing pool, $BINDING becomes tradeable, Shoppe revenue kicks in
Era 3: MaturityS16–S30Peak player count, competitive seasons, multiplayer adventuresStable pool, inflation managed by seasonal caps
Era 4: LegacyS31–S40The game is a classic, community-driven content, potential DAO governancePool stabilizes, long-term holders rewarded

Deflationary Revenue Curve

EraRevenue to $BINDING PoolWhy
Era 10.05%Higher % to bootstrap value. Early coins need to feel worth earning.
Era 20.03%More players = more total revenue, so % can drop while absolute $ grows.
Era 30.01%Stable, predictable, sustainable.
Era 40.005%Pool is self-sustaining, revenue goes to operations + community.

Control Mechanisms: The season structure gives three powerful levers to prevent the coin economy from spiraling: (1) Seasonal coin budgets cap $BINDING minting per season. (2) Leaderboard resets every 6 months prevent permanent accumulation spirals. (3) Era transitions every ~2.5 years are built-in checkpoints to adjust conversion rates, revenue %, and minting caps.

5. Replayability Engine

The same adventure should feel different every time you play it. The story beats stay fixed, but everything between the beats gets reshuffled.

Three-Layer Model

LayerWhat ChangesQuality Control
Layer 1: Curated Backbone20–30 hand-crafted scenes per adventure. Dependency graph. Tested.Guaranteed quality — the skeleton never breaks.
Layer 2: Procedural Connective TissueAI-generated transitions, side encounters, sub-plots, NPC moments.Starts with curated templates, learns player style, shifts toward free generation over time.
Layer 3: Surface VariationNPC personality, dialogue flavor, item descriptions, environmental details.Easy for LLMs to do well. Always different, never changes structure.

Adaptive Sub-Plot Generation

The AI DM builds a Player Profile as you play — tracking combat affinity, diplomacy, investigation, creativity, risk tolerance, and compassion. It uses this profile to:

The adaptation is invisible. Players should think “this adventure is really varied,” not “the game is testing me.”

Play Style Transparency

At the end of each adventure, players see a summary: “Your play style: Investigator. The game noticed you prefer exploring before fighting.” An optional deep profile view shows full style breakdown for hardcore players.

6. The Shoppe

Players find treasures during adventures — items, artifacts, relics. These items have three properties:

PropertyDetails
CosmeticDisplays on your player profile. Shows off your collection.
Gameplay BonusSmall cross-adventure utility. Found Dracula’s Signet Ring? Small bonus in vampire-themed adventures. Meaningful but not game-breaking.
Tradeable NFTReal on-chain asset. Sell to other players in The Shoppe marketplace. The Binding takes a small fee on each trade.

Anti-pay-to-win guardrail: No item should be powerful enough that buying it replaces playing well. The Shoppe rewards collection and curation, not spending power.

Seasonal scarcity: Items rotate in and out each season. If you were there, you got it. If not, there’s next season.

7. Dynamic Difficulty — Rubber-Band Scaling

The difficulty rubber-bands around the player’s level with deliberate power windows — periods where you’re overpowered followed by a challenge spike.

Fight TypeFrequencyPurpose
Standard challenge70% of fightsScales closely to your level. Constant engagement.
Power window20% of fightsBelow your level. You feel like a badass. Satisfying.
Challenge spike10% of fightsAbove your level. You need to think creatively. Humbling.

The AI DM controls the pacing — it knows when to let you feel powerful and when to humble you. This is narrative difficulty design, not just math.

8. Pre-Adventure Difficulty

Your character level determines the adventure’s baseline difficulty before you start. A Level 1 player gets an easier Dracula than a Level 10 player — same story, same beats, but enemies scaled, puzzles harder, DCs higher.

The difficulty is invisible. No numbers, no sliders. The AI DM narratively explains why this version is harder: “Word has reached you that this particular incarnation of the Count has grown more cunning. His servants are more numerous, his traps more elaborate.”

Difficulty is story, not a number. A player who thinks “this Dracula is really hard this time” is more engaged than one who thinks “the game scaled enemies to my level.”

9. Campaign Mode (Phase II)

The Binding will expand from book-based single-player adventures into a full AI Dungeon Master replacement for standard D&D 5e play. The same engine powers both modes.

Two Modes, One App

ModeDescriptionPlayersContent
Adventure ModePlay through a book (Dracula, Treasure Island, etc.)Single playerCurated scene graph + adaptive replayability
Campaign ModeStandard D&D with an AI DM — open-ended, improvisational2–6 playersAI-generated on the fly, guided by DM prompts

Campaign Mode Features

The multi-player D&D mode is essentially The Binding without the book constraint. Same engine, same AI DM, same rules — just open-ended instead of curated. This doubles the addressable market: “play through books” becomes “your personal D&D DM that’s always available.”

10. Phase 1 Architecture — Future-Proof Abstractions

Five architectural patterns are baked into Phase 1 so that Phase 2 (Campaign Mode) is purely additive — no rewrites. Two weeks of architectural discipline in Phase 1 saves 3–4 months of rewriting in Phase 2.

PatternPhase 1 (Now)Phase 2 (Campaign Mode)Savings
Session as containerSession holds a player array (length 1)Add players to the array (length 2–6)3–4 weeks saved
Player-tagged actionsEvery action includes playerIdAI DM processes actions from multiple player IDs4–6 weeks saved
Shared + private stateWorld state + private state exist (all visible to 1 player)Router filters private state per player2–3 weeks saved
Message routerDmMessage has targets array (length 1)Router broadcasts shared, whispers private2–3 weeks saved
Player-agnostic rulesRule engine accepts arrays of actorsWorks for 1 player or 6, zero changes0 (already done)

Net result: Phase 1 takes ~2 extra weeks to build with these abstractions. Phase 2 saves 11–16 weeks of rewriting. The ROI is 5:1 — the best investment in the entire project.

11. Scene System Design

Decided with Lawman: 2026-07-11

Core Principle: The DM never advances a scene unless the player chooses to move on OR the story forces it. Scenes have real weight — the player should feel like they’re in a place, not scrolling past it.

Scene Manifest

Every scene has a manifest — a checklist of discoverable content:

Scene: Golden Krone Inn Content: - talk_to_innkeeper → "Learn about Castle Dracula and its mysterious owner" - examine_crucifix → "Discover why the locals are so afraid" - find_old_woman → "The woman in the corner knows something about the castle" - check_stables → "The coach is ready. The horses are restless." - read_journal → "Jonathan Harker’s journal, left behind on a bench" Exit: - board_coach → "Leave for Castle Dracula" Hard_exit: - trigger: 4 turns after 75% completion → story forces transition

Completion Tracking

Exit Pressure Ramps (Narrative, Not Mechanical)

CompletionPressure LevelWhat the Player Experiences
0–25%BackgroundExit is one of 4 actions, not highlighted. Rich scene descriptions.
25–50%Gentle nudgeDM weaves in environmental cues. “The coachman coughs outside.”
50–75%Strong pushWorld closes in. “The candles burn lower. The coachman calls — he won’t wait.”
75–100%Story-drivenHard exit after 4 turns. “The innkeeper locks the door. Time to go.”

Suggested Actions (4 Total Each Turn)

Hard Exit Mechanism

What the Player NEVER Sees

This replaces the old approach where the DM just cycled through canned responses and forced scene transitions.

12. Multiplayer Roadmap

Decided: 2026-07-11. Phase 2 next, Phase 3 after testing Phase 2 with users.

Phase 1 (Current): Shared Controller

Phase 2 (Next): Host + Spectators

~2 hours of work. Natural fit for the product.

ComponentDetails
Session modelAlready supports players array (built from Day 1)
Player rolesNeed: role field on player (host vs spectator)
Spectator UINeed: spectator suggestion panel (visible only to spectators)
Host UIHost sees suggestions as a “community hints” overlay
MessagingSpectators get their own SSE stream with spectator-only messages
Why this first: Books have one protagonist. This respects the source material and makes the experience feel intentional rather than chaotic.

Phase 3 (Later): Full Co-op

Needs more design work. Rule engine already supports this.

ComponentDetails
Character creationNeed: flow for each player joining
Turn managementNeed: whose turn is it?
Information sharingNeed: shared vs private info (whisper system already in MessageRouter)
Multi-participant combatNeed: combat encounters with multiple participants
Co-op adventuresNeed: content written for 2–6 players
Why later: More complex, more engaging, but needs significant design work on how turns work in a narrative context.

Recommended Hardware & Connectivity Spec

The Binding is a browser-based Progressive Web App (PWA) that streams AI narration, renders dice animations, plays voice audio, and loads scene images in real time. This spec covers the minimum and recommended hardware, browser support, network requirements, and data usage for each phase of the platform.

Device Categories

CategoryMinimumRecommendedNotes
SmartphoneiPhone SE (2020) / Android 10+ with 3GB RAMiPhone 13+ / Pixel 7+ / Samsung S22+Primary target — 70%+ of players expected on mobile
TabletiPad (8th gen) / Android tablet with 4GB RAMiPad Air+ / Samsung Tab S8+Best landscape experience for campaign play
DesktopAny machine from 2018+ with 4GB RAMModern laptop/desktop with 8GB RAMChrome, Edge, Firefox, or Safari
ChromebookAny Chromebook with Chrome 100+Recent Chromebook with 4GB+ RAMFully supported — runs as PWA

Browser Support

BrowserMinimum VersionSupport Level
Chrome / Chromiumv100+Full — primary development target
Safari (iOS/macOS)v16+Full — voice input uses Web Speech API
Firefoxv100+Full — all features supported
Edgev100+Full — Chromium-based, identical to Chrome
Samsung Internetv17+Full — popular on Android devices
Opera MiniNot supported — lacks WebSocket/SSE support

Why PWA? No app store install required. Players open a URL and play. The PWA caches assets (dice animations, UI, fonts) for instant reload and partial offline support. Voice and AI features require an active connection.

Network & Connectivity

FeatureMin BandwidthRecommendedLatency ToleranceData per Session (1hr)
Text-only gameplay64 Kbps1 Mbps+< 2000ms RTT0.5–1 MB
+ Voice output (DM speaks)128 Kbps2 Mbps+< 1500ms RTT2–5 MB
+ Voice input (player speaks)256 Kbps3 Mbps+< 1500ms RTT3–7 MB
+ Scene images1 Mbps5 Mbps+< 3000ms RTT10–30 MB
+ Multiplayer (spectator join)1 Mbps5 Mbps+< 2000ms RTT5–15 MB
Full experience (all features)2 Mbps10 Mbps+< 1500ms RTT15–50 MB

Mobile data note: A 1-hour text-only session uses roughly 1 MB — about the same as loading a news article. Voice adds 2–5 MB. Scene images are the heaviest feature (10–30 MB/hour). Players on limited data plans can disable image generation in settings.

Performance Targets

MetricTargetHow We Achieve It
First contentful paint< 1.5sPWA precaching, minimal JS bundle, static shell
Text response time< 500msServer-sent events (SSE), streaming LLM responses
Voice response time< 2sStreaming TTS, audio starts playing before generation completes
Dice animation60fps, no jankPre-baked lottie sprites, GPU-accelerated transforms
Image generationBackground, non-blockingImages load asynchronously — gameplay never waits for art
Page interaction (TTI)< 2s on 3GCode splitting, lazy-loaded modules, minimal initial bundle

Audio Requirements

FeatureRequirementDetails
Speaker / headphonesRequired for voice featuresDM voice, NPC voices, ambient audio, dice sound effects
MicrophoneOptionalFor voice input (player speaks actions). Falls back to text if unavailable or denied.
Audio codec supportMP3 / AACAll modern browsers support both. OGG fallback for Firefox.

Storage Requirements

ItemSizeDetails
PWA cache (initial)5–15 MBApp shell, UI assets, fonts, dice animation sprites
Cached scene imagesUp to 100 MBOptional — player can clear cache in settings
Session data (localStorage)< 1 MBSession ID, rejoin code, player preferences, settings
Total recommended free space150 MBComfortable headroom for all cached content

Accessibility & Input

Input MethodSupport
TouchPrimary — tap suggested actions, swipe to scroll, long-press for context
KeyboardFull — tab navigation, enter to submit, number keys (1–4) to select actions
VoiceOptional — Web Speech API for input, TTS for output. Graceful fallback to text.
Screen readersPlanned — ARIA labels on all interactive elements, semantic HTML throughout

Network Resilience

Scaling Architecture

PhaseExpected LoadInfrastructure
Phase 1 (beta)50–200 concurrent sessionsSingle Render instance (free tier), in-memory sessions
Phase 2 (launch)500–2,000 concurrentRender standard tier, Redis session store, CDN for static assets
Phase 3 (growth)5,000–20,000 concurrentMulti-instance Render, Redis cluster, Paxeer Cloud frontend, database persistence
Phase 4 (scale)50,000+ concurrentAuto-scaling compute, global CDN, Paxeer-native frontend, sharded session stores
Every layer is designed to scale independently. The frontend moves to Paxeer Cloud. The session store moves from in-memory to Redis to a database. The coin ledger moves from in-memory to Paxeer smart contracts. The DM brain stays on a compute instance — it's the only layer that truly needs a server.

Security & Privacy

System Architecture

The Binding is a hybrid application: the game engine runs on a traditional server, and the economy/assets live on the Paxeer blockchain. This is the same architecture every major web3 game uses. A blockchain cannot run a game server, call AI APIs, or serve web pages — but it is the best place to own assets, process payments, and store player reputation.

A blockchain is a ledger, not a computer. The game runs on a computer. The rewards live on the ledger.

What Runs Where

LayerWhere It LivesWhat It Does
Game EngineRender.com (Node.js server)Fastify API server, session management, rule engine (D&D 5e dice math, combat, stats), scene engine, continuity validation
AI Dungeon MasterRender.com → OpenAI APIOrchestrates player action → context assembly → LLM call → narrative response + 4 suggested actions. Manages hot/warm/cold context tiers for 50+ hour adventures.
Frontend (PWA)Render.com (same server)Responsive HTML/CSS/JS served as static files. Service worker for offline shell. Polling-based real-time sync. Works on any device with a browser.
Player WalletsPaxeer Network (chain 125)PAX balance, token holdings, transaction history. MetaMask or any EVM wallet.
Character NFTsPaxeer Network (ERC-721)Dynamic NFTs that update as characters level up. Stats, portrait, achievements, tier badges on-chain.
$BINDING TokenPaxeer Network (ERC-20)Platform meme coin. Only minted through gameplay. Tier-weighted conversion from in-game coins.
Achievement BadgesPaxeer Network (ERC-1155)Soulbound (non-transferable) tokens earned through gameplay milestones.
MarketplacePaxeer Network (custom contract)NFT trading between players: adventures, dice sets, cosmetics. Royalties to creators.

Why It Cannot All Run On-Chain

NeedWhy Blockchain Can't Do ItWhere It Actually Runs
AI narrationSmart contracts cannot call external APIs (no HTTP requests from EVM)Server → OpenAI API
Session stateOn-chain storage costs gas per write. A 2-hour session = hundreds of state changes = hundreds of gas fees.Server memory (in-memory, zero cost, instant)
Web pagesA blockchain stores data, it does not serve HTML to browsersServer static file hosting
Dice rollingOn-chain randomness requires VRF oracles — expensive, slow, unnecessary for a single-player gameServer-side cryptographic random

Current Server Setup (Beta)

The game is deployed and running on Render.com. This is the simplest, lowest-cost setup for a Paxeer network beta test.

ComponentServiceMonthly CostStatus
Game server + frontendRender Starter plan$7/moNeeds upgrade from free tier (free tier spins down after 15 min idle — first visitor waits 30-60s)
LLM API (AI DM)OpenAI GPT-4o-mini$5–10/moNeeds API key added as env var on Render
Total for beta$12–17/moHandles hundreds of playthroughs

LLM cost breakdown: GPT-4o-mini costs $0.15 per million input tokens. A full Dracula playthrough (~30K tokens) costs about $0.01. One hundred playthroughs cost roughly $1. This is the cheapest model that produces quality narrative. GPT-4o (better quality) costs 10x more — about $0.15 per playthrough. We recommend starting with mini for beta and upgrading to GPT-4o for launch.

What Paxeer Network Users Need to Test

Testing PhaseWhat Players NeedWhat We Need
Phase 1 Beta (now)Just a URL. Open in any browser. No wallet needed. No install.Render paid tier + OpenAI API key
Phase 2 Beta (wallet connect)Paxeer wallet (MetaMask) + small PAX balance for gasWallet connection UI + smart contract for coin payouts
Phase 3 Launch (full on-chain)Paxeer wallet + PAX for transactionsDeployed smart contracts (NFTs, marketplace, $BINDING token)

What Is Needed to Build & Deploy

Immediate (Phase 1 Beta — this week)

  1. Render Starter plan — $7/mo. Toggle in Render dashboard. Eliminates cold starts.
  2. OpenAI API key — Free to create at platform.openai.com. Add $5-10 credit. Set as LLM_API_KEY env var on Render.
  3. Agent shell access — The build agent needs terminal access to push code, install dependencies, and run tests. This was working previously and appears to have been restricted.

Next (Phase 2 — Paxeer wallet integration)

  1. Paxeer wallet with PAX — For deploying smart contracts and testing payouts. The agent has an embedded wallet.
  2. Smart contracts — Character NFT (ERC-721), coin payout contract, achievement badges (ERC-1155). Written in Solidity, deployed to Paxeer chain 125.
  3. Wallet connection UI — MetaMask/WalletConnect integration in the frontend. Players connect their Paxeer wallet to receive coin rewards.

Later (Phase 3 — Full blockchain)

  1. $BINDING token contract — ERC-20 with gameplay-only minting. No ICO, no presale.
  2. Marketplace contract — NFT listings, purchases, royalties, escrow.
  3. Guild Pass contract — Subscription NFT with tier progression.
  4. Security audit — All contracts audited before mainnet launch with real funds.

Security Model

ConcernHow It's Handled
No PII on-chainPlayer names, emails, and game actions never touch the blockchain. Only wallet addresses and token balances are public.
HTTPS everywhereAll API traffic encrypted in transit. Render provides TLS certificates automatically.
Session isolationEach game session is fully isolated. No data leaks between sessions or players.
LLM data handlingPlayer actions are sent to OpenAI for narration. No player identity data is included. Conversation history is ephemeral.
Smart contract safetyContracts use OpenZeppelin standards. All contracts audited before mainnet. Agent wallet has spend limits enforced at the network layer.
Rejoin code securityShort-lived, session-scoped codes. Rate limiting prevents brute force.

Scaling Path

StageUsersInfrastructureCost
Beta (now)50–200 Paxeer testersSingle Render instance, in-memory sessions$12–17/mo
Launch500–2,000 concurrentRender standard tier, Redis for sessions, CDN for static assets$50–100/mo
Growth5,000–20,000 concurrentMulti-instance, Redis cluster, Paxeer Cloud frontend$200–500/mo
Scale50,000+ concurrentAuto-scaling compute, global CDN, sharded sessions$1,000–3,000/mo
The game engine is the only layer that needs a server. Everything else — frontend, assets, economy — can move to decentralized infrastructure over time. The architecture is designed so each layer scales independently.

Interactive Dice Roller

Real-time 3D physics-based dice. Click any die to roll it — the die tumbles with gravity, bounces off the table, and settles on a random result.

Multi-Die Rolls

Click any die to roll with real-time 3D physics. The die tumbles with gravity, bounces off the table, and settles on a random result. Tap the overlay to dismiss after the number appears.