Story Garden is a neurosymbolic game engine. Players speak to the world in plain language, and the engine's AI writes their wishes into the world's own scripting rules. Creatures remember what happened to them. Worlds keep living between sessions.
The first game built on Story Garden is a small voxel world called Magic Pet. You walk in with three magic verbs, a starter moonpetal in your inventory, and four named villagers — Rowan who keeps the grandmother's song in three verses, Ember who watches what you build, Selene who teaches the symbolism of ritual materials, and a wandering Merchant who arrives in a window and walks back into wilderness when it closes. The same engine could host other worlds and other verbs; Magic Pet is where it has been proven first.
!cast_spell <wish>
Type a wish. The engine gathers what you carry, what you have planted nearby, and the recent memories of the place. A villager within earshot speaks a witness line in their own voice as the cast unfolds, or you hear an italicized inner thought if you are alone. The AI then returns a fresh creature with a persona, memories, a home, and a behavior tree composed live, and the creature walks in with its own first words.
!pray <question>
A whisper to whatever's listening. The world-spirit answers in one short, in-character line. A voice through the air. No spawn, no item.
!plant <item>
Press something from your inventory into the ground. It stays where you put it, carrying its own memory — every item you pick up gets a one-line origin written by the AI when it enters your hand. Spells cast nearby read what you have planted. The place itself begins to remember.
Most games come with a list of things you can do: mine, craft, cast Fireball, trade. You learn the list, and the game becomes the list. Story Garden has no list. You ask for a small fox that knows where it came from, and a small fox walks into the village. It comes home at dusk to the spot where you cast it. It pauses near things you have planted. It recognizes you when you carry something it was made of.
Tomorrow you ask for something else, and that joins the village too. Nothing was patched. The new behavior was written by the engine's AI, in MiniScript, and ran from the next tick onward.
A simulation that listens, and changes.
Each NPC in Story Garden is a generative agent. It carries a searchable memory weighted by recency and importance. It has a persona that drifts as it accumulates experience. It runs a small tree of decision rules the engine evaluates every tick, and the AI can rewrite that tree from inside the world. Rowan keeps the grandmother's song in three verses and remembers who she sang each one to; push her too soon and she will tell you to give her a moment to gather her thoughts. Ember writes a creative assessment when something you built inspires her, and the line lands in chat where you can read it. Selene tracks which ritual materials she has explained to you and which she has not.
This is where an AI is most useful and least wasteful. Not narrating dialogue line by line, but composing the rules of a character's mind, and updating those rules when the imagination needs more. Pick up a moonstone and the AI writes a single line about where you found it; that line rides the stone wherever it goes. Plant the stone in a grove and the grove remembers it. Cast a spell nearby and the spell-weaver reads the grove's memory and writes the new creature's persona around it.
A creature you summoned last week comes home to the spot where you cast it at dusk. A creature whose origin included a moonpetal you carried lingers near other moonpetals, recognizing you when you carry one. A villager you have never asked something hands you a verse the merchant has not yet brought. All of these run as MiniScript the engine wrote into the world. Some were authored by hand. Others were composed mid-cast by the AI. The engine cannot tell them apart.
The world doesn't wait for the player. The merchant arrives in his window, trades for what he came for, and walks back into the wilderness when the window closes. Resources you gathered respawn on their own clocks. The day moves on a ten-minute cycle and certain creatures change behavior at dusk. None of this stops when you log off. None of it asks for your input.
And the player isn't fixed forever to the human at the center. Magic Pet binds the player verbs to a single human entity; the same engine could bind them to a fox, a stormfront, or the seasonal cycle in a different world. A Story Garden world is an ecosystem first, and the player takes a part in it.
There are two ways to put AI characters into a game. One is to ask an LLM to generate dialogue and decisions in real time, every frame, for every entity. That is expensive, slow, and the world drifts away from itself after a few minutes. Story Garden takes the other way.
A small symbolic engine carries every entity's behavior tick by tick. It is cheap, deterministic, and costs no AI tokens. The AI joins in at a higher layer, writing new behaviors and decision rules in MiniScript when its imagination is needed. What the AI writes runs.
An entity's behavior is a set of actions, each paired with an expression over named considerations, combined with fuzzy and, or, not, nested arbitrarily deep. A consideration is anything that returns a fuzzy number between 0 and 1. Every tick, every entity scores its tree, and the highest branch runs.
A village NPC's whole mind:
{
"INITIATE_DIALOGUE": "(player_in_interaction_range)",
"SHARE_MEMORY": "(player_distance_close
and (memory_sharing_opportunity or knows_song_fragment)
and not already_shared_with_player)",
"RECONSTRUCT_STORY": "(player_distance_close
and all_fragments_shared
and not story_already_reconstructed)",
"OFFER_COMFORT": "(player_distance_close
and player_seems_disheartened
and not recently_consoled)",
"WANDER_LOCAL": "(point_1)"
}
Some considerations are MiniScript functions, computing on position, memory, time, what's in someone's hand. memory_sharing_opportunity is one of them:
// memory_sharing_opportunity, fuzzy predicate, returns 0..1 memory_sharing_opportunity = function(args) selfPos = args["entity"]["pos"] targetPos = args["target"]["pos"] dx = selfPos.x - targetPos.x dy = selfPos.y - targetPos.y dz = selfPos.z - targetPos.z if sqrt(dx*dx + dy*dy + dz*dz) > 10 then return 0 social = args["entityData"]["social_memory"] last = social["last_interaction_with"][args["target"]["uid"]] if WorldTime() - last < 30 then return 0 return 1 end function
Other considerations are concepts the AI is asked to score directly: "does this player seem disheartened?", "is this build inspired enough to react to?", "is this offering meaningful for the ritual?". Anything the AI can assess and return as a number. No MiniScript at the leaf, just a value between 0 and 1, dropped back in for the next tick. The neurosymbolic seam doesn't sit at one boundary; it runs through every leaf.
The AI also authors at the higher layer. It composes new behaviors from the existing palette, and writes new actions and considerations as MiniScript when it needs them. Here is what the spell-weaver returned the day a player typed !cast_spell "a small fox that knows where it came from":
// spell-weaver output, hot-loaded into the live simulation { "RETURN_HOME": "(at_dusk and not at_home_location)", "APPROACH_FAMILIAR": "(player_distance_close and reminded_of_origin)", "LINGER_AT_MEMORY": "(near_planted_memory)", "WANDER_LOCAL": "(point_1)" } // near_planted_memory, a new consideration, written by the model near_planted_memory = function(args) pos = args["entity"]["pos"] planted = args["globalData"]["planted_memories"] for m in planted dx = pos.x - m["pos"].x dy = pos.y - m["pos"].y dz = pos.z - m["pos"].z if sqrt(dx*dx + dy*dy + dz*dz) < 5 then return 1 end for return 0 end function
Old palette, new tree, one new consideration. From the fox's first tick it scores against the same loop as every other villager. It runs every tick. It costs nothing afterward. It persists when the chat session is over.
Spells cast last week affect spells cast today. Plant a moonstone in a grove now, cast a spell there next week, and the spell-weaver reads the grove's memory. The simulation remembers what you carried, where you stood, who saw it.
Newly summoned creatures join the same fuzzy logic that runs everything else: a persona, origin memories, a behavior tree, scored against the same loop as the village NPCs. From their first tick, they belong.
The engine can grow new verbs the same way it grows new creatures. If a player invents a fishing rod, the AI can write the supporting behaviors — fish, near_water, hunger_for_protein — and every villager who wants to fish, can. The verb stays in the world. Magic Pet does not yet have a fishing rod; the move is the same one that spawns the fox.
What the AI writes at runtime is real code in a real engine. Inspectable, editable, versionable. Nothing vanishes when the chat session ends.
Most AI in games today is text generation pasted over the screen. Expensive narration. World state and conversation drift apart. The experience disintegrates as it runs. Story Garden takes the other path: an AI that fires only where its imagination is the point, and that writes in the engine's own rules when it does. The result, we hope, is a different kind of game. One where the question stops being what recipe should I follow, and becomes:
What story should you tell, and how should you tell it?
Subscribe for early access when Story Garden ships.
To play with it sooner, write us at dev@wunderstory.io.