Licensing

The short version

If you are a game studio, a researcher, a platform, or an independent developer considering a licence, the short version is this. The Cartographer gives you NPCs that learn on their own, participate in the village's economy, develop distinct personalities from their starting conditions, and run on modest hardware — at numbers that would be impossible with conventional AI NPCs. You do not need to train them, you do not need to retrain them when you add content, and you do not need to write branching logic for their behaviour. The rest of this page describes how this is possible and what adopting it means for your development process.

How VINE actors differ from conventional NPCs

The difference is architectural, not cosmetic, and it is worth getting clear on before the commercial question.

A conventional NPC has two things doing its thinking for it: a branching logic tree (chains of if and elif) and, in more modern systems, a neural network trained by gradient descent. Both approaches place the intelligence inside the NPC. The NPC is supposed to know what to do, and the system's job is to consult its rules or its weights and produce an action.

A VINE actor does not work this way. The intelligence is not inside the actor. The actor carries an algorithm and a set of concerns to be resolved, and what actually drives its behaviour is the topology of the world.

In a conventional system, an NPC walks into a room and consults itself about what to do. In the Cartographer, an actor walks into a room and the room itself participates in determining what the actor does next. An empty house presses differently than a full one. A rainy field presses differently than a sunny one. A hungry actor presses differently against a bakery than a fed one does. The actor resolves the pressures and acts.

Why the world has to have structure

This is the point that most licensees need to chew on before they are comfortable adopting the system.

Because the actors are not rule-based, the world must be. If the world does not have structure — givens, shapes, affordances, rules about what things are and how they relate — there is nothing for the actors to press against, and no way for any actor to understand what constitutes appropriate behaviour. The world's structure is what makes the actors intelligent.

The upshot is a clean inversion of where design effort goes. In a conventional game, designers spend their time on NPC logic: dialogue trees, behaviour trees, scripted responses. In a Cartographer-licensed project, designers spend their time on the world: its rules, its affordances, its shapes. Once the world is designed, the actors fall into line with it automatically.

Why this is computationally cheap

Because the topology of the world carries part of the load of determining behaviour, an actor does not have to recompute everything from scratch every moment. Moving through familiar territory is cheap — the structure of the place has already been resolved, and the actor is working against a known shape. Only when the shape changes — a new concern arising, an unexpected event, a tipping point — does fresh resolution actually need to happen.

This is the mathematical basis for why thousands of VINE actors can run on hardware that would choke on a handful of conventional AI NPCs. Most of the time, the actors are not "thinking" in the expensive sense. They are following the geometry of a world they already know.

The two headline technical facts

The actors do not have a fixed parameter count. The architecture is not a neural network of a particular size, trained once on a particular dataset, whose behaviour is locked in by the weights it happens to have ended up with. It is a geometric system, and it sizes to its world. Bigger world, bigger system; smaller world, smaller system. You do not pay for capacity you are not using, and you do not hit a ceiling when your world grows past what the model was trained on — because no such training exists.

The actors do not need retraining. If you want to add a new craft, a new biome, a new item, a new interaction — you add it the way you would normally add something to a game. You do not have to assemble a dataset. You do not have to spin up GPUs. You do not have to fight branching logic to wedge the new thing in beside the existing things. The architecture accommodates because the architecture is not locked to what it has already seen.

What changes in your development process

You design your world. Its rules, its givens, its affordances, its shapes. This is where your effort goes, and this is where your design control lives.

What you no longer need to do:

• Write behaviour trees for your NPCs.
• Author dialogue trees.
• Assemble a training dataset.
• Retrain anything when you add content.
• Write chains of branching logic to handle edge cases of NPC interaction.
• Hand-script the small-scale quests (gather, fetch, deliver) — these emerge from the actors' real needs.

What you still do:

• Design the world's rules and affordances.
• Author the narrative quests your story depends on.
• Create your art, assets, lore, and world-flavour.
• Decide the shape of your game. The Cartographer is a substrate; you decide what grows on it.

Compute envelope

The numbers here will seem implausible. They are accurate, and there is a live demonstration you can interact with directly on the website.

The production server — not a local machine, the live Hetzner server — classified 49,746 items across 53 folders in 780.7 milliseconds, at 64,000 items per second. On a local Ryzen the throughput is higher still. The live cruncher is on this site. You can run it yourself.

The full fleet runs light on consumer hardware. A formal compute profile will publish with the licensee pack; prior informal testing has shown many simultaneous instances on a modest fraction of a consumer GPU with headroom remaining. The whole pipeline runs as a geometric walk with no branching logic: there are no decision trees to traverse, no probability distributions to sample, no gradient to follow. Per-agent compute is effectively instantaneous.

This is not an optimisation achievement. It is a property of the architecture. The reason conventional AI-NPC systems scale badly is that each NPC is doing expensive inference per tick. VINE actors are not doing inference. They are settling into a basin. The difference in compute cost is not marginal — it is architectural.

The practical upshot: a single modest server can run a village at full fidelity. The system is small enough to scale to global deployment. The bottleneck, if there is one, will be your rendering layer — not the agents.

Speech

The actors speak via the VINE mixture-of-experts language layer — small narrow-task specialists that inflate an actor's internal state into natural language. This layer is included with the Cartographer licence. The overview page covers how it works in more detail.

What a licensee receives

[To be specified: the precise commercial package — engine access, documentation, integration support, update cadence, permitted modifications, etc.]

The engine is asset-agnostic. You bring your own art, your own characters, your own lore, your own IP. The village will take the shape you give it.

How to get in touch

[To be specified: contact details, preferred first-contact channel, expected response window.]

← Return to the Cartographer overview.