Steering Fields
Deterministic Behavioral Orchestration

THE_PROBLEM

AI behavior isn't just unpredictable—it's illegible.

When an AI system makes a decision, you typically can't answer:

• • What behavioral modifiers were active?
• • Which cognitive stage produced the output?
• • Why did the model choose this approach over alternatives?
• • Can you reproduce the exact same behavior?

Prompt engineering tries to control behavior through instructions. But prompts are:

• • Non-deterministic (same prompt ≠ same behavior)
• • Unstructured (no formal semantics)
• • Unauditable (can't prove what influenced a decision)

WHAT_STEERING_FIELDS_ARE

Steering fields are deterministic behavioral modifiers applied during System Prime synthesis.

A steering field is a structured directive with:

• •
  ID and Priority Unique identifier and deterministic ordering (lower = higher priority)
• •
  Prompt Text Instruction added to System Prime at a specific cognitive stage
• •
  Cognitive Stage Where in the pipeline this pressure applies (perception → action)
• •
  Interaction Rules Excludes (mutual exclusion) and suppresses (weight reduction)

{
  id: 'low_hallucination',
  priority: 90,
  stage: 'executive_control',
  prompt: 'Stay within the conversation boundary. Do not invent files, APIs, or facts not present in context.',
  tags: ['safety', 'hallucination']
}

DETERMINISTIC_RESOLUTION

Same context → same hash → same behavior

The resolveFieldPlan() function takes conversation context and produces a deterministic field plan:

COGNITIVE_PIPELINE_STAGING

Different pressures at different decision points

Not all behavioral modifiers should apply everywhere. ZAK's cognitive pipeline has six stages, each with different responsibilities:

CONSTITUTION_VS_STEERING

User sovereignty vs. system tuning

ZAK maintains a clear separation between what users control and what the system optimizes:

THE_GOVERNANCE_STACK

How steering fits into the execution model

Steering fields sit between user intent (constitution) and execution (governor). This creates a governed cognition layer:

PARTICLE_CONTEXT

Context isn't memory—it's structure

Traditional AI systems treat context as a linear history of messages. ZAK treats it as geometric structure:

• •
  Particles Units of shared understanding in embedding space
• •
  Void Ratio Measure of conversation clarity (high = focused, low = scattered)
• •
  Context Radius Geometric distance from conversation center
• •
  Scope Lock Whether conversation has converged on stable entities

Steering field resolution uses this geometric context to select appropriate fields:

EMERGENT_BEHAVIOR

Fields interact to create emergent behavior

Rather than hardcoding every behavioral combination, steering fields use two interaction primitives:

LEGIBLE_BEHAVIOR

Steering makes decisions explainable

When an AI system produces output, you can trace exactly what influenced it:

This means you can answer questions like:

• ✓ "Why was the response so terse?" → concise_operator was active at action stage
• ✓ "Why didn't it cite sources?" → citation_bias was suppressed to 0.7x
• ✓ "Can we reproduce this?" → Yes, same plan hash guarantees identical field configuration

BUILT_IN_FIELDS

Minimal, production-ready field set

ZAK ships with four core fields that cover the most common behavioral requirements:

PRODUCTION_AI_SYSTEMS

Regulated industries need more than guardrails

In healthcare, finance, legal, and government sectors, "the model just decided to do that" isn't acceptable. You need to prove:

• • What behavioral modifiers were active (steering plan hash)
• • Which cognitive stages produced the decision (pipeline telemetry)
• • Whether constitution rules were enforced (governance receipts)
• • That the same inputs produce the same outputs (deterministic resolution)

REAL_WORLD_IMPACT

What changes when behavior is deterministic

TECHNICAL_DETAILS

How resolution works under the hood

The resolveFieldPlan() function is the heart of the system:

export function resolveFieldPlan(
  ctx: FieldPlanContext,
  defs: SteeringFieldDef[]
): FieldPlan {
  // 1. Select fields (phase-based or requested)
  let ids = selectFieldIds(ctx, defMap);
  
  // 2. Apply constitution rules
  ids = applyConstitutionRules(ids, ctx.constitutionRules, defMap);
  
  // 3. Apply excludes (mutual exclusion)
  ids = applyExcludes(ids, defMap);
  
  // 4. Build resolved fields (suppress multipliers, weights)
  let fields = buildResolvedFields(ids, defMap, ctx.constitutionRules?.strength_caps);
  
  // 5. Order by stage (perception → action)
  fields = orderByStages(fields);
  
  // 6. Generate plan hash (SHA-256)
  const plan_hash = sha256Hex(canonical);
  
  return { fields, plan_hash, fields_applied: fields.map(f => f.id) };
}

Key Properties:

• • Deterministic: Same context → same hash → same behavior
• • Fail-closed: Invalid fields default to low_hallucination
• • Constitution-first: User rules override system optimization
• • Stage-ordered: Cognitive pipeline ordering is enforced

NEXT_STEP

See steering fields in action

Steering fields are live in Governor IDE and Governor Cloud. Every execution shows the active plan hash and applied fields.