9 - CERBERUS_World-Driven_Agency_v0.1_Verified_Release.docx

CERBERUS WORLD-DRIVEN AGENCY Deterministic, Explainable Behavior Through Semantic Worlds SK RULE REQ SKILL EQUIP GOAL TASK WORLD Illustrative Architecture Paper Version 0.1 | August 2026 Core proposition Complex agents can remain comparatively simple when the world itself carries explicit semantic state, action logic, requirements, Rules, affordances, and shared operational structure. Semantic state • Logic planes • Bounded cognition • Goals • Affordances • Tasks • World continuity EXECUTIVE SUMMARY Abstract World-Driven Agency is a CERBERUS architecture for producing complex, reproducible, and explainable behavior from comparatively thin agents operating inside a semantically explicit world. Instead of duplicating domain logic inside every non-player character, the world carries reusable Semantic Kernels, state Models, Rules, requirement mappings, equipment capabilities, task structures, and authoritative state. Characters contribute bounded comprehension, skills, knowledge, memory, Goals, and access. Their behavior emerges from the interaction between those local limits and the possibilities already registered in the world. The central technical pattern extends the SK Reader beyond semantic decoding. Once a BitWord is parsed and a semantic identity is resolved, the same address can query parallel linked definition planes: semantic meaning, Rule Type, competency level or Level Mask, and requirement routing. A compact requirement code can direct the Reader toward no external dependency, a Skill check, an Equipment search, or both. The result is not merely a label such as JULIENNE; it is a traceable operational contract that says what the action means, what kind of transition it represents, what competence it requires, and what environmental capability must be found before it becomes available. Goals then operate over this registered possibility space rather than inventing arbitrary behavior. Assets expose the states they can occupy; Operators bind valid transitions; World Rules modify local applicability; current environment, TIME, knowledge, Skills, and equipment determine affordances; plans compile those affordances into Tasks; and shared Task Boards coordinate eligible executors without making Tasks properties of individual characters. When a Task is reassigned, responsibility changes while the Task identity and dependency chain remain stable. The architecture is deterministic in the operational sense: given the same authoritative state, declared Rules, actor knowledge, capability state, Goal weights, and explicit stochastic inputs, the system can reproduce and explain why a behavior was selected. Randomness can still exist, but it is treated as an explicit bounded input rather than an unexplained substitute for causal structure. Relationship to the Storyboard Continuity Engine This paper is a companion to the CERBERUS Storyboard Continuity Engine (SCE). SCE establishes continuity over addressable semantic World State, Goal persistence until meaningful reconsideration, the separation between World Truth and bounded character knowledge, the distinction between Behavior and Simulation, and the authority boundary between proposals and Committed Deltas. World-Driven Agency specializes the middle of that loop: how a bounded actor resolves what it can understand, which semantic transitions are available, why one transition is selected, how work becomes shared Tasks, and how those commitments return to SCE as attempted behavior and consequential world change. Architectural inversion The NPC carries a bounded perspective. The world carries reusable domain logic. What this paper formalizes Why domain logic can live in reusable Semantic Kernels and linked logic planes instead of being duplicated inside each NPC. How the same resolved semantic coordinate can bind meaning, Rule Type, Level requirements, and external dependencies. How the 00 / 01 / 10 / 11 requirement router separates no requirement, Skill, Equipment, and combined resolution. How Skills, Language Masks, Knowledge, Memory, environment, World Rules, and TIME bound actor affordances. How Goals search registered state-transition possibilities rather than hard-coded NPC scripts. How causal explanation can trace an action from Goal through semantics, requirements, Rules, resources, and assignment. How Tasks remain first-class shared objects whose ownership can change without moving or duplicating the Task. How Task Boards and cross-board dependencies allow organizations and communities to coordinate through shared operational state. How meaningful events trigger selective reconsideration while stable behavior continues without full-frame decision rebuilding. How the same architecture scales from JULIENNE on one potato to a restaurant, farm, transport chain, and community production goal. Scope This is an illustrative architecture paper. It defines the semantic and causal relationships that make world-driven agency possible. It does not prescribe one database, game engine, scheduler, AI model, rendering system, or exact Airtable schema. Detailed SK Reader formulas, BitGroup offset mathematics, complete equipment taxonomies, full World Rule libraries, physical simulation, DARTBOARD implementation, and engine-specific task executors remain neighboring or downstream specifications unless they are needed here to define an interface. NAVIGATION Paper Map Part Theme Purpose 1 A World That Carries Behavior Move behavior logic from bespoke NPC scripts into reusable semantic world structures. 2 Semantic Logic as Action Contract Resolve BitWords into meaning, Rules, requirements, Skills, equipment, and executable transition state. 3 The Bounded Agent Define the minimal actor through Language, Skills, Knowledge, Memory, Goals, and Access. 4 Goals, Affordances, and Explainability Turn desired states into constrained possibilities and reproducible causal action traces. 5 Tasks and Shared Agency Externalize commitments into Tasks, Boards, ownership relationships, and actor eligibility. 6 Community-Scale Causality Scale the same logic across a tomato-stew request, farm production, logistics, and kitchen scheduling. 7 Continuity and Growth Reconsider only when cause exists; let growth change behavior by changing state rather than code. 8 The Integrated Agency Cycle Close the architecture back into SCE World State, formal principles, and responsibility boundaries. The figures form a parallel visual argument. The first movement establishes where behavior logic lives. The second shows how one semantic coordinate can produce an operational contract. The third bounds the actor. The fourth makes selection explainable. The fifth externalizes work into shared operational state. The final movements show community-scale causality, event-driven reconsideration, and closure back into persistent World State. PART 1 A World That Carries Behavior Complex behavior becomes easier to author when reusable domain logic lives in the world instead of being copied into every character. 1. Where Does the Behavior Live? Conventional game-agent design often starts by placing behavior inside the character. A cook receives cooking logic, tool logic, recipe logic, timing logic, substitution logic, and a growing collection of exceptions. A farmer receives a different private stack. As the world grows, every profession, species, machine, and social role tends to accumulate another bespoke behavior tree or script family. World-Driven Agency begins from the opposite direction. The world already contains canonical semantic structures that define food, cooking, equipment, locations, Rules, Tasks, and state transitions. An NPC does not need a private copy of those definitions. It needs enough bounded state to interpret and participate in them. The same cooking operation can therefore be resolved by a chef, apprentice, robot, or future actor type without rewriting what JULIENNE means for each one. Figure 1. Where Does the Behavior Live? Character-heavy design duplicates domain logic inside the actor; world-driven design keeps reusable semantic logic in the world and gives the actor only the bounded state required to participate. Design principle World logic before character logic. 2. Intelligence Is Distributed Moving logic out of the NPC does not create a new monolithic 'World AI.' Agency is distributed across independently governed structures. Semantic Kernels define meaningful state; Assets carry current state; World Rules constrain local applicability; the actor contributes Skills, knowledge, perception, preferences, and Goals; the environment contributes available objects and locations; TIME contributes deadlines and changing conditions. Behavior emerges from their intersection. This distribution is what makes the architecture explainable. If a transition is unavailable, the system can identify the failed dependency instead of hiding the decision inside an opaque behavior script. The missing cause may be a Skill level, equipment category, inaccessible location, unknown resource, blocked World Rule, unmet predecessor, or invalid time window. Each source remains separately addressable. Figure 2. Intelligence Is Distributed. Behavioral possibility is derived from several independent semantic and runtime sources rather than owned by one character script or one central decision module. 3. Asset as Semantic State Carrier An Asset is not a behavior script with a picture attached. It is an addressable thing whose current state can be represented through the Models relevant to it. A potato may carry FOOD, COOKING, FOOD_SAFETY, LOCATION, TEMPERATURE, and other bounded Models. Those Models do not collapse into one hierarchy; each retains its own semantic ownership while describing another dimension of the same Asset. This means the object itself can expose what kinds of state changes are meaningful. If a FOOD or COOKING Model defines whole, peeled, diced, julienned, boiled, or roasted states, the potato occupies one point in that semantic territory at the current moment. Other actors do not need to guess what can happen to the object from its visual appearance alone; they can query the Models the object already carries. Figure 3. Asset as Semantic State Carrier. One Asset can participate in several independent Models without duplicating identity or collapsing those Models into one ontology. 4. Models Expose Possibility Space A Model defines possibility before it defines availability. JULIENNED can be a valid food state even when no knife, cutting surface, skilled actor, or permitted work area is present. The Model therefore answers a structural question: what states are meaningful and what semantic transitions can exist between them? Runtime context answers a different question: which of those transitions can be executed now? Separating possibility from current availability prevents a common modeling error. If an operation becomes temporarily blocked, the world does not forget that the state exists. A broken knife, closed kitchen, missing worker, or restrictive Rule changes the current edge through the state space; it does not erase the semantic territory itself. Figure 4. Models Expose Possibility Space. Semantic states remain valid possibilities even when the live world does not currently satisfy the requirements needed to reach them. PART 2 Semantic Logic as Action Contract The SK Reader can resolve not only what a state means, but the rule class and dependencies that determine what can happen next. 5. From Binary State to Operational Meaning The existing SK Reader architecture already provides the first half of the agency problem. A BitWord identifies its ordered BitGroups. Their widths and offsets parse the canonical binary state. Encoding Type selects the appropriate mathematical interpretation. The Reader then resolves the relevant semantic address or identity from the linked semantic definition. World-Driven Agency extends that pattern without changing the canonical binary. Once the Reader has resolved the semantic identity, it can use the same coordinate to query additional SK-linked definition tables. The binary remains compact state. The additional tables remain reusable definitions. The Reader becomes the temporary place where those layers are combined into a human- and machine-readable operational contract. Figure 5. From Binary State to Operational Meaning. BitWord structure and Encoding Type resolve compact binary state into the semantic identity that downstream logic can address. 6. One Semantic Coordinate, Many Logic Planes The key pattern is that Semantic Bits need not be the only linked plane available to the Reader. The same resolved address can identify a semantic meaning, a Rule Type, a Level requirement or Level Mask, a Requirement Type, a Skill route, and an Equipment route. These are parallel definitions attached to the same semantic coordinate, not additional copies of instance state. For a resolved address such as B047, the semantic plane might return JULIENNE, the Rule plane CUTTING_TRANSFORM, the Level plane 3, the Requirement plane 11, the Skill route CUTTING, and the Equipment route CUTTING_TOOL. The Reader can therefore reconstruct the exact reason why this semantic possibility requires particular external conditions. Figure 6. One Semantic Coordinate, Many Logic Planes. A single resolved SK identity can bind meaning, rule class, competency level, and external dependency metadata without expanding the canonical Word. Plane Example resolution Semantic JULIENNE Rule Type CUTTING_TRANSFORM Level 3 Requirement Type 11 Skill Route CUTTING Equipment Route CUTTING_TOOL Reader consequence One resolved semantic identity can become a complete action contract. 7. Requirement Type as a Logic Router A compact two-bit requirement classification can route the next resolution step. The base four states are deliberately simple: 00 means no external Skill or Equipment requirement; 01 routes to Skill resolution; 10 routes to Equipment resolution; and 11 requires both. The code is not the action itself. It tells the Reader which dependency systems must be consulted before the action can become available. Because Requirement Type is definition metadata, it does not need to consume bits in the instance Word when the requirement is stable for that semantic operation. The Word remains the current state. The linked definition plane tells the Reader how to interpret the consequences of that state. If a particular World modifies the requirement, the base definition remains intact and the World Rule changes local applicability downstream. Figure 7. Requirement Type as a Logic Router. The 00 / 01 / 10 / 11 code selects no dependency, Skill resolution, Equipment resolution, or both without changing the semantic identity of the operation. Code Resolution path 00 No external Skill or Equipment requirement 01 Resolve Skill requirement 10 Resolve Equipment requirement 11 Resolve both Skill and Equipment 8. Skill Requirement Resolution Skill requirements are comparatively cheap to resolve because competence is actor state. A semantic action can declare CUTTING at Level 3. A character with CUTTING Level 4 passes the requirement; a character at Level 2 does not. The important point is that the character does not need a private JULIENNE script. The Skill profile only answers whether this actor satisfies the competence demanded by the shared operation. A simple monotonic threshold is sufficient for many Skills, while a Level Mask can support non-monotonic or explicitly permitted ranges where needed. The architecture does not require every domain to use the same competency mathematics. It requires the requirement to be explicit, addressable, and comparable to actor state. Figure 8. Skill Requirement Resolution. The action declares the Skill and required Level; actor state determines whether that branch of the contract passes. 9. Equipment Requirement Resolution Equipment resolution works differently because the required capability lives in the environment rather than in the actor. A semantic operation should generally request an equipment category or capability such as CUTTING_TOOL, not a hard-coded object identity such as Knife #4827. The category can then route through an equipment taxonomy to acceptable implementations and finally into the actor's known and accessible environs. This permits substitution without weakening determinism. A chef knife, santoku, mandoline, robotic cutter, or a World-specific tool can satisfy the same broad requirement if the applicable Rule says that implementation is valid. The Reader and planner can explain which category was requested, which candidate was found, and which Rule admitted it. Figure 9. Equipment Requirement Resolution. A semantic capability requirement routes from broad equipment category to acceptable implementation and then to an actual accessible Asset in the local environment. 10. Julienne: Complete Semantic Contract JULIENNE demonstrates the whole micro-scale chain. The Reader resolves the semantic identity and Rule Type. Requirement Type 11 opens both dependency branches. The Skill branch resolves CUTTING Level 3 against the actor. The Equipment branch resolves CUTTING_TOOL against the environment and finds an acceptable knife. World Rules then determine whether the otherwise valid combination is permitted in this location for this actor. If every dependency passes, the operation becomes available. Nothing has yet been physically changed. Availability means that the semantic world has identified a valid, currently satisfiable transition. Behavior still has to attempt it, Simulation still has to determine what actually happens, and only an authorized consequential result can become committed World State. Figure 10. Julienne: Complete Semantic Contract. One semantic identity resolves through Rule, requirement routing, Skill, Equipment, environment, and World Rules to produce an explainable availability result. Critical boundary Available means executable in the current context. It does not mean the outcome has already occurred. 11. Possible, Available, Attempted, Resolved World-Driven Agency requires explicit state classes for action. Possible means the Model permits the transition to exist. Available means current requirements and Rules allow an actor to attempt it. Attempted means Behavior has been issued. Resolved means Simulation has mediated the attempt through the active world. Committed means the authorized consequential delta has become canonical state. These distinctions protect causal explanation. A plan can be valid without succeeding. A skilled actor can attempt an operation and still be interrupted. A tool can satisfy a category requirement yet fail mechanically during execution. The world therefore preserves the difference between semantic eligibility, intention, physical consequence, and authoritative mutation. Figure 11. Possible, Available, Attempted, Resolved. Semantic possibility, runtime eligibility, behavior, simulation, and committed state are related stages rather than synonyms. PART 3 The Bounded Agent The NPC becomes comparatively thin because comprehension, capability, knowledge, goals, and access are bounded state rather than duplicated domain logic. 12. The Minimal NPC Once the world carries domain logic, the actor profile can become surprisingly small. A minimal NPC needs identity and physical state, a Language Mask describing what semantic identities it can resolve, Skills describing which capability requirements it can satisfy, Knowledge and Memory describing what world information it can use, Goal Logic describing what outcomes currently matter, and Access describing which locations, resources, organizations, and Task Boards it can reach. This is a minimum architectural profile, not a claim that characters have no personality, body, relationships, emotions, or social history. Those can remain additional Models. The important change is that profession-specific behavior no longer has to be embedded as a separate private logic tree. Two characters can run the same agent architecture while living radically different lives because their semantic access and current state differ. Figure 12. The Minimal NPC. A bounded actor can participate in a rich semantic world through a compact profile of comprehension, capability, knowledge, goals, memory, and access. 13. World Truth, Language, and Knowledge World Truth, semantic comprehension, and character knowledge must remain separate. The World may canonically know that an object is an industrial mandoline. A character's Language Mask determines whether that exact identity can be resolved. The character's Knowledge then determines what facts about that identity are available: where one is stored, how to use it, who owns it, or whether it is safe. This separation allows bounded cognition without corrupting canonical truth. A character can understand the word MANDOLINE but not know where one is. Another can see a machine and only resolve the broader category CUTTING_EQUIPMENT. A third may know the exact equipment, location, and operating constraints. They inhabit the same world while possessing different operational realities. Figure 13. World Truth, Language, and Knowledge. Canonical identity, semantic comprehension, and known facts are distinct layers of actor access. 14. Same World, Different Minds Language Masks make perception semantically bounded rather than merely visually filtered. When two characters encounter the same machine, one may resolve its precise registered identity while another resolves only a broader category. The object has not changed. The difference lies in what each actor can interpret from the same world state. This provides a compact basis for expertise, education, culture, secrecy, developmental stages, and unfamiliar technology. Characters do not need separate scripted reactions for every unknown object. The same semantic hierarchy can return the deepest identity each Language Mask is permitted to understand, while Knowledge determines what the actor can do with that understanding. Figure 14. Same World, Different Minds. Different Language Masks can resolve different semantic depths from the same canonical object without changing World Truth. 15. Skills Change the Action Space Character growth can change behavior without adding new behavior code. When CUTTING rises from Level 2 to Level 3, every registered operation requiring CUTTING Level 3 can become newly eligible, subject to its other requirements. The actions were already defined in the semantic world; progression changes which requirement checks the actor can satisfy. This makes Skill development structurally meaningful. Training does not unlock a hand-authored branch attached only to one character class. It changes a reusable piece of actor state, and the consequences propagate automatically through every compatible SK and Operator that references that Skill. Figure 15. Skills Change the Action Space. Growth in actor capability exposes additional already-registered transitions without rewriting the agent. 16. Knowledge Changes Reachability Capability is not enough if the actor cannot resolve the dependencies needed to use it. A character may satisfy CUTTING Level 4 while failing to find a cutting tool because the available knife is in a drawer they do not know about. Another character with the same Skill can resolve the route immediately because that location is part of their bounded knowledge. Knowledge therefore changes practical reachability without changing semantic possibility. The world can contain a valid solution that a particular actor cannot currently discover. Perception, teaching, memory, communication, exploration, or Task Board information can later expand the actor's known environment and make the same transition operationally reachable. Figure 16. Knowledge Changes Reachability. The same capability and environment can produce different local solutions when actors know different routes to required resources. PART 4 Goals, Affordances, and Explainability Goals identify desired consequence; the semantic world determines which registered transitions can actually move current state toward that consequence. 17. Goal Logic Specifies Desired Consequence Goal Logic should not have to contain the choreography for reaching a Goal. 'Prepare 30 Tomato Stews' describes a desired consequential state. It does not need to name the farmer, truck, chef, prep worker, exact harvest hour, or knife that will eventually participate. Those details are planning outcomes derived from the live world. This keeps Goals stable while execution remains adaptive. If the farm changes, a chef becomes unavailable, or another source of tomatoes appears, the desired consequence can remain the same while the causal route changes. Goal owns direction and priority; the planner owns how current registered possibilities can satisfy it. Figure 17. Goal Logic Specifies Desired Consequence. The Goal defines what must become true while live planning determines the actors, resources, timing, and transitions required to reach it. Goal law Goal specifies consequence, not choreography. 18. Goal to Semantic Possibility Search Planning begins from the difference between current state and desired state. It resolves the Models relevant to that difference, identifies registered Operators that can move those Models, evaluates their requirement contracts, and constructs candidate causal routes. The planner therefore searches a world-defined transition space instead of inventing unconstrained actions. Missing requirements become causal problems rather than mysterious failures. If tomato stew requires tomatoes and inventory is insufficient, the planner can route the resource gap into acquisition. If acquisition depends on harvest, harvest becomes a subordinate requirement. If harvest depends on equipment repair, the dependency can expand again. Recursive planning remains grounded because every expansion follows a declared requirement rather than free-form speculation. Figure 18. Goal to Semantic Possibility Search. Planning walks from current state toward desired state through registered Models, Operators, requirements, and feasible causal routes. 19. How an Affordance Is Derived Affordance is the current intersection between semantic possibility and runtime context. It is not stored as a permanent property of the object. The same JULIENNE transition may be available in a kitchen with a skilled actor, cutting surface, accessible knife, valid time window, and permissive Rules, yet unavailable seconds later if the knife breaks or a Rule changes. The derivation can include Model possibility, current Asset state, Operator requirements, actor capability, Language and Knowledge, environment, TIME, and World Rules. Because each input remains separately addressable, the system can explain not only that an action is unavailable, but which condition prevents it and what kind of prerequisite would make it available again. Figure 19. How an Affordance Is Derived. Current action availability emerges from semantic possibility intersected with actor state, environment, knowledge, TIME, and Rules. 20. Explain Why This Action Was Chosen Explainability is not a diagnostic feature added after decision-making. It falls directly out of the architecture. The system can trace a selected action backward through the Goal that demanded it, the semantic operation that can satisfy the Goal, the Rule that makes the operation valid, the Skill and Equipment checks that made it available, the time and predecessor conditions that made it actionable now, and the assignment policy that selected the executor. For JULIENNE, an explanation can therefore be literal: the recipe requires a julienned state; COOKING exposes JULIENNE as a valid transformation; Requirement Type 11 demands CUTTING Level 3 and CUTTING_TOOL; the actor has CUTTING Level 4; a chef knife is known and accessible; World Rules permit the action; the wash predecessor is complete; and the actor is eligible on the Kitchen Board. The explanation is the causal trace itself. Figure 20. Explain Why This Action Was Chosen. Goal, semantics, requirements, resources, Rules, timing, and assignment combine into a reproducible explanation trace. Explainability principle Every selected behavior should be traceable to the conditions that made it reasonable and permitted. 21. Deterministic Does Not Mean Identical Determinism here means reproducible causal resolution, not identical worlds. When all authoritative inputs are the same, a deterministic selector can return the same result. If variation is desired, stochastic choice can remain explicit: candidate weights, probability policy, and a seed or other declared random input become part of the resolution state. This distinction preserves both variability and explanation. The system can say that Chef A was selected because it had the highest declared score, or that Chef B was selected from an eligible weighted set using a recorded stochastic input. Randomness is therefore bounded and inspectable rather than used to hide missing logic. Figure 21. Deterministic Does Not Mean Identical. Reproducible rule-based selection and declared stochastic selection can both remain explicit and explainable. 22. World Rules Modify Applicability Semantic Kernels define the base domain. World Rules sit above that domain and change local applicability without rewriting canonical meaning. JULIENNE can remain a cutting transformation requiring Skill and Equipment while one World prohibits robots from using exposed blades and another World allows a magical cutting capability to substitute for a physical tool. This separation is crucial for portability. The same SK library can participate in a realistic restaurant, an educational simulation, a robotic factory, or a fantasy World. The domain definition remains stable. World Rules declare what the local reality permits, forbids, modifies, or substitutes. Figure 22. World Rules Modify Applicability. Local Rules can prohibit, modify, or substitute requirements while leaving the underlying SK semantic contract intact. PART 5 Tasks and Shared Agency Plans become shared operational commitments. Tasks persist independently from whichever actor currently owns or executes them. 23. Plans Become Tasks A causal route becomes actionable when it is compiled into Tasks. A Task is a bounded operational commitment to attempt a desired transition or satisfy a requirement. It can carry a target, dependencies, capability requirements, resources, timing, priority, status, Board, and current owner without becoming the canonical world consequence itself. The compilation need not be one Operator equals one Task. A transition can decompose into several operational steps, or several low-level transitions can be grouped into one Task at the level useful for coordination. What matters is that dependencies and outputs remain explicit enough for the runtime to determine when work becomes Ready, Blocked, Active, or Complete. Figure 23. Plans Become Tasks. A selected causal route is externalized into bounded operational commitments with dependencies and timing rather than kept as private actor intention. 24. Task Ownership Is a Relationship Tasks should not live inside characters. If Chef A drops a Task and Chef B takes it, the system should not delete the Task from one character and paste a duplicate into another. The Task identity, Goal relationship, dependencies, timing, history, and output remain stable; only the ownership relationship changes. This simple separation has large consequences. Work continuity survives staffing changes, actor failure, shift changes, robot substitution, or organizational reassignment. The Task remains a first-class piece of shared operational state, while responsibility is one mutable link attached to it. Figure 24. Task Ownership Is a Relationship. Reassignment changes who is responsible for a Task while preserving the Task identity and its causal context. Task identity law Responsibility changes. The Task persists. 25. Task Board as Shared Operational State Task Boards provide bounded operational surfaces through which actors, teams, robots, or organizations can see and act on work. A Board can expose Ready, Blocked, Claimed, Active, and Complete Tasks according to access and role. It is more than a visual UI because it represents a governed relationship between shared Tasks and the actors permitted to operate on them. A broader Task Matrix can connect Boards through cross-board dependencies, timing, requirements, and status propagation. The Farm Board, Transport Board, Kitchen Board, and Service Board can remain independently useful surfaces while still participating in one causal fabric. This avoids forcing every participant to share one giant personal task list. Figure 25. Task Board as Shared Operational State. Multiple actors can access a bounded work surface while Tasks retain their own status and identity. 26. Actors Compete or Qualify for Shared Work Assignment happens after the Task exists. The Task declares what it needs: perhaps Kitchen access, CUTTING Level 3, availability within a time window, and compliance with a World Rule. Candidate actors are evaluated against that contract. Several may pass; others may fail because of Skill, access, Rules, workload, knowledge, or timing. A declared assignment policy can then select among the passing candidates. The policy might prefer proximity, lowest workload, highest Skill, social role, organizational ownership, deterministic score, or bounded stochastic variation. Actor identity becomes a scheduling result rather than a hard-coded property of the Task definition. Figure 26. Actors Compete or Qualify for Shared Work. Task requirements first determine eligibility; a separate declared policy selects among eligible executors. 27. Community Coordination Without Private Handoffs Shared operational state reduces the need for brittle person-to-person task transfer. A customer order can create or update Tasks on the appropriate Board. When the waiter completes order capture, kitchen work becomes actionable through the same shared causal state. The waiter may still speak to the chef socially, but the computational Task does not have to migrate through the waiter as private memory. The same pattern scales across organizations. A farm can update an ETA and downstream transport or kitchen Tasks can reconsider their own timing without requiring a chain of bespoke notification scripts. Actors coordinate by changing governed shared state that other authorized systems can read. Figure 27. Community Coordination Without Private Handoffs. Shared Task state lets multiple actors respond to the same operational truth without transferring the Task object from one character to another. PART 6 Community-Scale Causality The same semantic and task logic that resolves one cutting operation can coordinate farms, logistics, kitchens, and service around a shared production Goal. 28. Thirty Tomato Stews: Goal Expansion Consider a request for thirty tomato stews. The Goal is not 'tell a chef to cook.' It is the desired state: thirty finished servings available for service under the applicable recipe, food-safety, timing, and resource constraints. Recipe resolution identifies required ingredients and operations. Inventory resolution then discovers that tomatoes are insufficient. That shortage becomes a causal requirement. The system can search for acquisition possibilities, route to an accessible supplier, and expose a farm requirement without embedding agricultural choreography inside the restaurant. The Farm Board receives a bounded need, while the farm remains free to resolve its own crop state, labor, equipment, weather, knowledge, and timing internally. Figure 28. Thirty Tomato Stews: Goal Expansion. A service Goal expands through recipe and inventory dependencies into an upstream agricultural requirement without preassigning the actors who will satisfy it. 29. Thirty Tomato Stews: Cross-Organization Causality Suppose the farm initially predicts a Thursday 16:00 harvest. That ETA becomes a proposal available to downstream planning. Transport can schedule collection, receiving can reserve a window, prep can estimate start time, and the kitchen can check which chefs are available after the expected tomatoes arrive. None of those plans turn the future harvest into canonical fact. If rain moves the harvest expectation to Friday 10:00, the changed proposal propagates through the affected dependency neighborhood. Transport, receiving, prep, chef scheduling, cooking, and service can reconsider their timing. Unrelated Tasks need not be regenerated. When tomatoes actually arrive, the corresponding World State changes, blocked downstream Tasks can become Ready, and the kitchen continues the causal chain toward the thirty-servings Goal. Figure 29. Thirty Tomato Stews: Cross-Organization Causality. An upstream farm ETA can coordinate transport, receiving, prep, chef availability, cooking, and service while remaining a proposal until the underlying world event actually occurs. Community consequence Complex community behavior can emerge from shared causal state rather than bespoke inter-character choreography. PART 7 Continuity and Growth Stable action continues until cause justifies reconsideration, while changes in Skill, Language, Knowledge, or Access naturally change future behavior. 30. Reconsider Only When Cause Exists World-Driven Agency inherits SCE's continuity-before-reconsideration principle. An actor does not need to rebuild its entire decision state every frame. If the current Goal, Task, target, requirements, and Rules remain valid, the behavior can continue. Reconsideration occurs when a meaningful event changes the assumptions under which the current choice was made. Triggers can include Task completion, tool failure, a new perception event, a TIME threshold, Goal priority change, World Rule change, newly available work, lost access, or changed knowledge. The system can then reevaluate the affected causal neighborhood instead of discarding the actor's complete state and rerolling from nothing. Figure 30. Reconsider Only When Cause Exists. Stable Goals and Tasks persist until an explicit event changes the conditions that made the current behavior valid. 31. Growth Without New Behavior Scripts Because behavior is derived from shared semantic contracts, progression becomes ordinary state change. Skill growth causes more requirement checks to pass. Language growth lets the actor resolve more specific semantic identities. Knowledge growth reveals new resources, routes, and facts. Access growth exposes additional locations, organizations, Boards, and equipment. The actor can therefore become dramatically more capable without receiving new bespoke behavior code. A novice and expert may run the same agent architecture. Their difference lies in what they understand, what they know, what they can satisfy, and what they are allowed to reach. The world automatically exposes the newly eligible possibilities. Figure 31. Growth Without New Behavior Scripts. Changes to Skill, Language, Knowledge, and Access alter the actor’s future action space without changing the underlying agent architecture. PART 8 The Integrated Agency Cycle Bounded perception becomes Goal-directed action through semantic contracts, affordances, shared Tasks, Simulation, and committed World State. 32. The World-Driven Agency Cycle The complete cycle begins in authoritative World State. Perception exposes only the context available to the actor. Language and Knowledge determine what that context means to this particular character. Goal Logic identifies the desired state that matters now. The runtime then searches SK and Model possibilities, resolves Operator logic planes, applies World Rules, derives current affordances, composes a causal plan, and externalizes the plan through Tasks and shared Boards. Eligible actors attempt the resulting behavior. Simulation mediates those attempts through the actual world. Authorized consequential results become Committed Deltas and update World State. The new state changes what can be perceived, known, afforded, planned, and pursued in the next cycle. Agency is therefore neither a private character script nor a universal central controller; it is a recurring relationship between bounded actors and a semantically explicit world. Figure 32. The World-Driven Agency Cycle. Bounded perception and Goal Logic route through semantic possibilities, logic planes, World Rules, affordances, Tasks, eligible actors, Behavior, Simulation, and Committed Delta before returning to new authoritative World State. World-driven agency The NPC supplies bounded perspective and capability. The world supplies the structured possibilities that make behavior coherent. 33. Formal Principles of World-Driven Agency Principle Meaning World Logic Before Character Logic Place reusable domain meaning and action logic in shared semantic structures wherever practical instead of duplicating them across actors. Semantic State Can Carry Operational Meaning An SK can resolve not only what a state means but which Rule and dependency structures govern its transitions. One Semantic Coordinate, Many Logic Planes The same resolved semantic identity can bind meaning, Rule Type, competency requirements, equipment requirements, and other governed metadata. Requirement Type Routes Resolution Compact requirement classes determine which dependency systems the Reader must consult. Capability Is Actor State Skills describe which semantic requirements a particular actor can satisfy. Equipment Is Environmental Capability Operations request equipment classes or capabilities and resolve them against actual accessible Assets. Comprehension Is Bounded Language and Knowledge constrain what part of World Truth an actor can operationally interpret and use. Goals Specify Desired Consequence Goal Logic identifies what should become true without hard-coding the complete execution choreography. Affordances Are Derived Current action availability emerges from semantic possibility intersected with actor state, environment, TIME, and Rules. Tasks Externalize Commitment Planned work exists as shared operational state independently from the actor currently responsible for it. Assignment Is a Relationship Changing the executor does not change Task identity. Shared State Coordinates Communities Organizations can coordinate by publishing and updating governed Task state rather than transferring private intentions. Reconsideration Requires Cause Stable Goal and Task state persists until a declared event invalidates or supersedes the current choice. Randomness Must Be Declared Stochastic variation is an explicit input to causal resolution, not an unexplained replacement for logic. Every Action Should Be Explainable A selected behavior should be traceable through Goal, semantics, requirements, Rules, resources, timing, and assignment. Consequences Return to World State Only resolved and authorized consequences become the canonical starting state of what happens next. 34. Responsibility and Implementation Boundaries World-Driven Agency does not replace the systems it routes through. BIGFOOT and SK Readers retain semantic structure and deterministic interpretation. World Rules retain local governance. SCE retains continuity over authoritative World State and the distinction between Behavior, Simulation, Proposal, and Committed Delta. DARTBOARD can retain operational orchestration. Praxis and simulation systems retain actual interaction resolution. Task Boards coordinate shared commitments without becoming the owner of every participating Model or Asset. The architecture also does not prescribe one implementation substrate. The current Airtable design can use linked SK tables, REGEX-based semantic address resolution, Formula records, Level masks, requirement-routing categories, and Board records as transitional infrastructure. A future runtime can compile the same contracts into more efficient native structures without changing the semantic boundaries defined here. Explicit non-scope This paper does not define every Semantic Kernel, Skill, equipment category, Rule, recipe, or Task type used by a World. It does not prescribe a universal planning algorithm, scoring formula, stochastic policy, or scheduler. It does not replace detailed SK Reader, BIGFOOT, SCE, DARTBOARD, Praxis, Effects, Skene, or engine-specific specifications. It does not assume that every event requires full Task-board planning; bounded immediate behaviors may resolve with much smaller subsets of the architecture. It does not make planned future state canonical merely because a schedule or ETA exists. It does not grant actors omniscient access to World Truth, resources, or Task Boards. 35. Conclusion — The World Does the Heavy Lifting World-Driven Agency reframes autonomous character design. Instead of asking how much behavior must be packed into every NPC, it asks how much reusable meaning can be made explicit in the world. Semantic Kernels define states and operations. Logic planes expose Rules and requirements. Skills and Language bound the actor. Equipment and Knowledge ground action in the environment. Goals identify desired consequences. Task Boards preserve shared commitments. Simulation determines what attempts actually become. The result is a system in which comparatively simple agents can produce complex, differentiated, community-scale behavior without becoming collections of bespoke scripts. A chef is not intelligent because it contains every cooking rule. It is capable because it can understand some part of a world that already knows what cooking means, satisfy some of that world's requirements, pursue Goals, and participate in shared Tasks. That architecture also makes behavior inspectable. When an actor acts, CERBERUS can trace the Goal, semantic operation, Skill requirement, equipment resolution, World Rule, timing condition, Board state, assignment decision, attempted Behavior, simulated consequence, and committed result. Complexity remains, but it is moved into explicit structures that can be reused, tested, changed, and explained. Closing proposition A semantically explicit world can carry complex agents. The richer the world contract becomes, the less bespoke behavior must be hard-coded into each character. APPENDIX A Compact Requirement Router Reference Requirement Type Meaning Resolution 00 No external Skill or Equipment requirement Continue to other applicable conditions and World Rules. 01 Skill requirement Resolve Skill identity and Level / Level Mask against actor capability. 10 Equipment requirement Resolve equipment category into acceptable implementations and search accessible environment. 11 Skill + Equipment requirement Both dependency branches must resolve before the operation becomes available. Operational state ladder State Boundary Possible The semantic Model permits the transition to exist. Available Current requirements, knowledge, environment, TIME, and Rules permit an attempt. Attempted An actor or system has issued Behavior intended to perform the transition. Resolved Simulation has determined what the attempt became in the world. Committed An authorized consequential mutation has updated canonical World State. APPENDIX B Relationship to Neighboring CERBERUS Systems System Boundary in this paper BIGFOOT / SK Readers Own Bit, BitGroup, BitWord, Formula, and deterministic semantic interpretation. This paper consumes resolved semantic identities and linked logic planes. BOSS / Semantic Registry Supplies stable symbolic and semantic identities where those representations are required. SCE Owns persistent causal continuity, Goal persistence, bounded knowledge, Behavior/Simulation separation, and closure back to authoritative World State. DARTBOARD Coordinates operational direction and runtime orchestration without becoming the semantic owner of every subsystem it routes through. Praxis / Simulation Determines what attempted Behavior actually becomes under active world conditions. World Rules Govern local applicability, permissions, substitutions, thresholds, and constraints without redefining the underlying SK domain semantics. Task Boards / Matrix Coordinate shared operational commitments and dependencies; they do not replace canonical World State or character cognition. Source architecture This paper was composed as a companion architecture to CERBERUS Storyboard Continuity Engine: A World That Exists Between Frames, version 0.2 (August 2026), and follows the human-gated OctoGroove document-compilation method defined in OCTOGROOVE AI Execution & BOOTSTRAP Guide, version 1.0 (August 2026). The present paper specializes explainable agency and task determination while preserving the responsibility boundaries established by those neighboring artifacts.