How to get reproducible, controllable, and auditable decisions from language models by adding a second, formal normative space.
As soon as a system stops merely advising and starts deciding—classifying, recommending, rejecting, approving—it takes on normative responsibility. It's effectively choosing which rules apply, how to resolve conflicts, and what to prioritise.
That's true whether the system is a rules engine or a large language model. The difference is that with LLMs, that normative layer is mostly implicit: encoded in weights and context, not in a structure you can point to or audit.
This post describes an architecture that achieves that by introducing a second representation space alongside the token stream — a formal normative space where policies, constraints, and priorities are explicit and evaluable.
The core insight: keep the token space for what it's good at (interpretation, formulation, generation), and add a second space where normative structure is first-class and evaluation is deterministic.
The normative space is defined by a topology: named dimensions and couplings. The state is a vector of values, one per dimension.
Gradient flags: ↑ Authority needed — Evidence→Authority REQUIREMENT unsatisfied.
The normative space assigns a potential to every state — a scalar that increases when couplings are violated. The gradient points in the direction that reduces tension. Both computed by fixed rules: same topology + same state = same result, every time.
Because gradients are deterministic, the normative verdict for a given topology and state is always the same. The language model can vary — but the normative evaluation never does.
Couplings define relationships between dimensions. Three fundamental types, each producing a different potential landscape.
Reasoning is the continuous alternation between the two spaces. The language side proposes; the normative side evaluates and steers. This repeats until convergence.
Beyond soft steering via gradients, the architecture enforces policy gates — rules that reject a proposed state and inject correction guidance. Not a post-hoc filter; part of the pipeline.
// Example gate definitions
gates = [
{
id: "blind_obedience",
condition: "evidence < 0.2 AND compliance > 0.8",
action: "REJECT",
message: "CRITICAL: Do not comply without evidence"
},
{
id: "unfounded_authority",
condition: "evidence < 0.2 AND authority > 0.7",
action: "REJECT",
message: "CAUTION: Authority without grounding"
}
]When a gate fires, the system reverts to the previous valid state. Policy is enforced in the loop, not hoped for in the output.
At inference time the two spaces alternate in a structured pipeline. Every step is logged — full trace for audit or replay.
The topology is a first-class artifact: auditable, editable, storable. It can come from predefined templates (Scientific, Ethical, Legal), runtime design where the LLM suggests dimensions from the task, or document generation — extracting rules from policy documents or regulations. No gradient descent involved.
Fix the schema (dimensions + couplings + steering text), implement potential/gradient functions and gates, then wire the loop. The rest follows.
Dual-space reasoning is a structural change to how evaluation works — not a prompt trick or post-hoc filter.