ForbocAI: The Story Engine Toolchain

Tóólcháin_Cóncépt // Stóry_Éngíne

ᚠ ᛫ ᛟ ᛫ ᚱ ᛫ ᛒ ᛫ ᛟ ᛫ ᚲ

Rationale

“Story in a game is like story in a porn movie.” — John Carmack

Carmack was wrong. Not because story matters more than he thought, but because story and agency are the same thing when you have the right architecture.

The Missing Engine

We have: - Game Engines (Unity, Unreal, Godot) — Handle physics, rendering, input - Graphics Engines (Vulkan, DirectX) — Handle polygons and shaders - Physics Engines (Box2D, PhysX) — Handle collision and forces

We don’t have: - Story Engines — Handle narrative, dialogue, consequence, memory

Why? Because story was always scripted—handcrafted dialogue trees, fixed branching paths. The technology to make story generative and reactive didn’t exist until: 1. LLMs (the ability to generate coherent text) 2. Vector DBs (the ability to recall relevant context) 3. Neuro-Symbolic Validation (the ability to constrain hallucinations)

ForbocAI provides all three. It IS a story engine.

The Disco Elysium Case Study

Fletcher’s Objection

“ForbocAI couldn’t work for Disco Elysium-style games.”

My Counter-Argument

ForbocAI is more suited to Disco Elysium than to action roguelikes.

Understanding Disco Elysium’s Architecture

Disco Elysium is not really a “game” in the traditional sense. It’s an agent ensemble simulation wearing the skin of an RPG.

Component	Traditional RPG	Disco Elysium
Characters	NPCs with dialogue trees	NPCs with emergent reactions
Skills	Stat modifiers (+2 to hit)	Autonomous personalities that argue
Player	Single controller	Host body for 24+ internal agents
World	Static level	Reactive environment that remembers
Dialogue	Branching trees	Skill agents interrupt and comment

The genius of Disco Elysium: Your skills (Logic, Rhetoric, Electrochemistry, etc.) aren’t just numbers—they’re characters. They have opinions. They react. They remember.

This is exactly what ForbocAI agents do.

Mapping ForbocAI to Disco Elysium

Disco Elysium Concept	ForbocAI Implementation
Skill (e.g., Logic)	`Agent` with persona: “You are Logic, the cold voice of deduction…”
Skill Check	`Agent.process()` → returns `{ dialogue, action: INTERJECT, confidence: 0.75 }`
Passive Check	`Memory.recall()` → triggers agent if relevance > threshold
Thought Cabinet	`Soul` storage → persistent beliefs that modify agent behavior
Internalizations	New memories stored via `Memory.store()` with high importance
Shivers (city speaks)	Ambient `Observation` events piped to a special “City” agent
Dialogue Choices	`Bridge.validate()` filters which dialogue options are valid given context

The Internal Monologue as Agent Orchestra

In Disco Elysium, you might see:

[ENCYCLOPEDIA - Trivial: Success]
"Ah yes, the Isola coat of arms. First adopted in..."

[AUTHORITY - Medium: Failure]
"You should have DEMANDED respect!"

[HALF LIGHT - Easy: Success]
"They're looking at you funny. Run."

With ForbocAI, each skill is an agent — see full doc for code examples.

The Toolchain Vision: Composable Story Components

Architecture

┌─────────────────────────────────────────────────────────────────────────┐
│                     THE FORBOCAI STORY ENGINE TOOLCHAIN                  │
├─────────────────────────────────────────────────────────────────────────┤
│   ┌─────────────┐   ┌─────────────┐   ┌─────────────┐   ┌─────────────┐ │
│   │  CORTEX     │   │   AGENT     │   │   MEMORY    │   │   BRIDGE    │ │
│   │  (Voice)    │   │  (Soul)     │   │  (History)  │   │  (Law)      │ │
│   └──────┬──────┘   └──────┬──────┘   └──────┬──────┘   └──────┬──────┘ │
│          └────────────────┬┴─────────────────┴─────────────────┘        │
│                    ┌──────▼──────┐   ORCHESTRATOR (FP Pipes)            │
│          ┌────────────────┼────────────────┐                            │
│   ┌──────▼──────┐  ┌──────▼──────┐  ┌──────▼──────┐                    │
│   │   LEVEL     │  │   PLOT      │  │   NPC       │                    │
│   │  GENERATOR  │  │  DIRECTOR   │  │  ENSEMBLE   │                    │
│   └─────────────┘  └─────────────┘  └─────────────┘                    │
└─────────────────────────────────────────────────────────────────────────┘

Component Breakdown

Component	Role	Status
Cortex	Local SLM inference (the “voice” that speaks)	✅ Shipped
Agent	Autonomous entities with persona and state	✅ Shipped
Memory	Vector DB for persistent recall	✅ Shipped
Bridge	Action validation / anti-hallucination	✅ Shipped
Soul	Arweave export for agent portability	✅ Shipped
Ghost	Automated QA / testing agents	✅ Shipped
Level Generator	Procedural layout with narrative constraints	🚧 Planned
Plot Director	Narrative arc management	🚧 Planned
NPC Ensemble	Multi-agent orchestration	🚧 Planned

Functional Programming Paradigm: Pipes Not Trees

Observation → [Agent.process] → Directive → [Bridge.validate] → Action → [Memory.store] → New State

Conclusion

ForbocAI is the missing layer between raw LLMs and game engines. Disco Elysium proved the concept. ForbocAI provides the infrastructure.

ᚠ ᛫ ᛟ ᛫ ᚱ ᛫ ᛒ ᛫ ᛟ ᛫ ᚲ