The Trader

Barter logic

Any actor at point of sale has barter logic. It is a permanent bolt-on — once gained, it does not go away. An actor who has graduated to selling has the ability to negotiate, and that ability stays with them.

Currently, Cedric — the village's primary trader — carries barter logic. The architecture is written as if every selling actor does; any gaps will be corrected as testing confirms.

The throwaway instance

When a customer enters a shop, the trader does not look up a price. Instead, they spool up a throwaway instance — a small, ephemeral process created for this transaction and discarded when it is done.

This instance takes a reading of the customer's current state: how badly they need what they are looking for, how much they value the specific item, the shape of their mood and their means. From this, it builds a mental model of the customer as they stand at the point of sale — a quick, operational picture of who this buyer is right now, in this moment.

The barter loop runs against this model. The final price is the outcome. Then the instance is gone. No persistence, no overhead, no memory of it. The transaction has occurred and the shopkeeper goes back to being a shopkeeper.

The final price is not fixed

The price the customer pays depends on more than what the item is worth. It depends on the state of the trader making the sale.

A trader under tension — tired, stressed, having had a difficult morning — can and will offload some of that tension into the transaction. The customer pays more. Not because the item changed. Because the person selling it is in a particular state, and that state flows into the price.

A trader in good form on a warm afternoon might price generously. Not as a programmed behaviour — because that is what their current state produces.

The customer sees none of this. They do not see the throwaway instance, the barter loop, the tension reading. They are standing in a shop getting a price. From where they stand, it is just commerce.

Why this works: the exposed conductor

This is where the Cartographer's architecture does something that other systems structurally cannot.

Passing internal state between AI instances in a transformer-based system produces noise. The conductor — the mechanism that would route state cleanly — is not exposed in transformer architectures. When instances try to share information, the signal degrades. It arrives distorted, hallucinated, unreliable.

In VINE, the conductor is explicit and exposed. An actor's internal state can be passed as clean, simple values — single digits — to wherever they are needed. The trader's tension state is a real number that the barter instance reads directly. Not an approximation. Not reconstructed from context. The actual value, cleanly routed.

This is why the trader's bad day flows into a price without glitching. The conductor carries it.

The scope of this principle

The same conductor that routes the trader's state into a transaction can route it anywhere. An actor's internal state is just a value, and it can be applied to whatever the architecture connects it to.

A trader's tension, in principle, could be piped to a patch of petunias in a distant forest. On days the trader is stressed, the petunias die. Nobody in the village would ever trace the connection. The conductor is invisible and the petunias just die.

This is the same principle as the astrology engine: something real is affecting the world, the cause lies outside the world's local causal structure, and it is ungameable because it is undetectable from inside.

← Return to the Cartographer overview.