Definition

The Transition Protocol is the formal mechanism governing the shift from the NABLA Infinity exploration phase to the No Mercy, No Doubts (NM/ND) execution phase within the Prismatic Platform. It defines the precise conditions under which uncertainty-tolerant investigation transforms into decisive, commitment-driven action. The protocol is not advisory -- it is a structural constraint enforced at the runtime level, preventing both premature execution (acting on unverified beliefs) and analysis paralysis (perpetually gathering evidence without commitment).

The protocol addresses a fundamental tension in any intelligence or decision-making system: the exploration phase values doubt, contradiction preservation, and parallel hypothesis maintenance, while the execution phase demands certainty, singular commitment, and complete follow-through. These two modes are philosophically incompatible -- a system cannot simultaneously preserve contradictions and act decisively on a single conclusion. The Transition Protocol resolves this tension by defining an explicit, verifiable boundary between the two phases, ensuring that the shift occurs only when the evidence warrants it and never prematurely.

At its core, the Transition Protocol requires three simultaneous conditions before any transition is authorized: the computed confidence score must meet or exceed the context-appropriate confidence threshold, the Trinity Gate must pass all verification layers (structural, logical, formal, and meta-integrity), and all seven NABLA Infinity axioms must be fully satisfied. If any single condition is not met, the system remains in exploration mode, and the transition is blocked.

Historical Context and Motivation

The Transition Protocol emerged from observing two catastrophic failure patterns in AI-assisted decision systems. The first pattern, premature execution, occurs when systems act on conclusions before sufficient evidence has been gathered. This is the more visible failure mode -- a security assessment that declares "all clear" based on incomplete scanning, a due diligence report that misses a critical beneficial ownership link because the investigation terminated too early, or an automated compliance check that passes a non-compliant entity because the confidence calculation ignored contradictory signals.

The second pattern, analysis paralysis, is subtler but equally destructive. Systems that never commit to action because there is always more evidence to gather, another source to check, or another contradiction to resolve provide no value despite consuming resources. In the absence of a formal transition mechanism, teams oscillate between these modes based on subjective judgment, organizational pressure, or arbitrary deadlines rather than evidential sufficiency.

Early versions of the Prismatic Platform (Generations 1 through 5) relied on human judgment to determine when exploration had been "sufficient." This worked for small-scale investigations but broke down as the platform scaled to hundreds of concurrent investigations. Analysts had different thresholds, and the same evidence set could trigger action from one analyst and continued investigation from another. The Transition Protocol was introduced in Generation 6 to replace this subjective judgment with a formal, verifiable, reproducible criterion.

The Three Transition Conditions

Condition 1: Confidence Threshold Crossing

The first condition requires that the computed confidence score for the belief or conclusion under evaluation meets or exceeds the threshold appropriate for the decision context:

Decision Context	Required Threshold (tau)	Rationale
Critical Decisions	>= 0.95	Security assessments, compliance determinations, production deployments
Standard Operations	>= 0.80	Routine platform decisions, agent coordination, data processing
Exploratory Analysis	>= 0.60	Research hypotheses, pattern exploration, preliminary findings
Research Queries	>= 0.50	Speculative analysis, early-stage investigation

The confidence score is computed by the QEVE pipeline, which integrates evidence strength, source independence, signal plurality, time decay, and contradiction indices into a single calibrated probability. The score is not a subjective estimate -- it is a mathematical function of the evidence graph, computed deterministically from the same inputs.

Critically, the threshold is not just a number to beat. The confidence calculation itself enforces NABLA axioms: contradictions reduce confidence (they cannot be hidden to inflate the score), absence of expected evidence reduces confidence (missing signals cannot be ignored), and correlated sources are discounted (ten articles from the same press release do not multiply confidence by ten).

Condition 2: Trinity Gate Passage

The second condition requires successful passage through all layers of the Trinity Gate:

Structural Consistency: The belief graph forms a valid DAG with no circular reasoning, orphaned nodes, or hidden contradictions
Logical Consistency: All inference steps are sound, premises support conclusions, and no NABLA axiom is violated
Formal Necessity: The conclusion is provably necessary (not merely probable) given the evidence, verified through modal logic and Lean4 theorem proving
Meta-Integrity: The gate mechanism itself is verified -- gates evaluated independently, scope is complete, no tampering detected

Trinity Gate passage is binary -- there is no partial passage. A belief that passes structural and logical checks but fails formal necessity has not passed the Trinity Gate. The transition remains blocked until all layers pass or the belief is revised to address the formal gap.

Condition 3: Full Axiom Compliance

The third condition requires that all seven NABLA Infinity axioms are satisfied for the belief under evaluation:

Signal Plurality: Minimum two independent signals support the belief
Contradiction Preservation: All contradictory evidence is explicitly preserved and annotated
Absence Informative: Missing expected signals are tracked and factored in
Time Decay: All evidence carries timestamps with appropriate decay applied
Unknown Valid: Any unknown sub-components are properly propagated
Source Independence: Correlated sources are identified and discounted
Provenance Mandatory: Complete chain of custody from raw data to conclusion

Axiom compliance is verified continuously during exploration, not just at transition time. However, the transition check serves as a final gate, catching any axiom violations that may have been introduced during late-stage evidence integration.

Transition State Machine

The Transition Protocol is implemented as a finite state machine with four states and strictly defined transitions:

                    +-----------------+
                    |   EXPLORING     |
                    | (NABLA active)  |
                    +--------+--------+
                             |
                    evidence accumulates
                    confidence computed
                             |
                             v
                    +--------+--------+
                    |   EVALUATING    |
                    | (Gate checking) |
                    +--------+--------+
                             |
               +-------------+-------------+
               |                           |
          ALL conditions              ANY condition
             met                        failed
               |                           |
               v                           v
     +---------+---------+      +----------+----------+
     |     EXECUTING     |      |     EXPLORING       |
     | (NM/ND active)    |      | (back to gathering) |
     +---------+---------+      +---------------------+
               |
          action complete
               |
               v
     +---------+---------+
     |     COMPLETED     |
     | (outcome logged)  |
     +-------------------+

The transition from EXPLORING to EVALUATING is triggered automatically when the confidence score crosses the threshold. The system does not wait for manual initiation -- threshold crossing triggers gate evaluation immediately. If the gate evaluation fails, the system returns to EXPLORING with a diagnostic report indicating which condition failed and what evidence would be needed to resolve it.

The transition from EVALUATING to EXECUTING is irreversible within a single decision cycle. Once execution begins, the No Mercy doctrine requires complete follow-through. There is no mechanism to "un-transition" back to exploration mid-action. This irreversibility is by design -- it forces the gate evaluation to be thorough, because there is no safety net of "we can always go back."

Elixir Implementation

The Transition Protocol is implemented as an OTP GenServer with full supervision, telemetry, and enforcement:

defmodule PrismaticNabla.TransitionProtocol do
  @moduledoc """
  Manages the transition from NABLA Infinity exploration phase to NM/ND
  execution phase. Enforces the three mandatory transition conditions:
  confidence threshold crossing, Trinity Gate passage, and full axiom
  compliance. Implements a finite state machine with four states:
  exploring, evaluating, executing, and completed.

  The protocol is non-bypassable. No configuration option, authority
  level, or runtime flag can disable transition enforcement.
  """

  use GenServer

  alias PrismaticNabla.{AxiomChecker, ConfidenceMonitor}
  alias PrismaticTrinityNexus.GateEvaluator

  @type state :: :exploring | :evaluating | :executing | :completed
  @type transition_result ::
          {:ok, :executing}
          | {:error, :confidence_insufficient, float()}
          | {:error, :gate_failed, GateEvaluator.failure_report()}
          | {:error, :axiom_violation, AxiomChecker.violation_report()}

  @spec evaluate_transition(belief_id :: String.t(), context :: atom()) ::
          transition_result()
  def evaluate_transition(belief_id, context \\ :standard) do
    GenServer.call(__MODULE__, {:evaluate_transition, belief_id, context})
  end

  @spec current_state(belief_id :: String.t()) :: state()
  def current_state(belief_id) do
    GenServer.call(__MODULE__, {:current_state, belief_id})
  end

  @spec transition_report(belief_id :: String.t()) ::
          {:ok, TransitionReport.t()} | {:error, :not_found}
  def transition_report(belief_id) do
    GenServer.call(__MODULE__, {:transition_report, belief_id})
  end

  @impl GenServer
  def handle_call({:evaluate_transition, belief_id, context}, _from, state) do
    threshold = threshold_for_context(context)

    with {:ok, confidence} <- ConfidenceMonitor.compute(belief_id),
         :ok <- check_confidence(confidence, threshold),
         {:ok, :passed} <- GateEvaluator.evaluate(belief_id, context),
         {:ok, :compliant} <- AxiomChecker.verify_all(belief_id) do
      emit_telemetry(:transition_authorized, belief_id, confidence)
      new_state = transition_to_executing(state, belief_id, confidence)
      {:reply, {:ok, :executing}, new_state}
    else
      {:error, reason} = error ->
        emit_telemetry(:transition_blocked, belief_id, reason)
        {:reply, error, state}
    end
  end

  @spec threshold_for_context(atom()) :: float()
  defp threshold_for_context(:critical), do: 0.95
  defp threshold_for_context(:standard), do: 0.80
  defp threshold_for_context(:exploratory), do: 0.60
  defp threshold_for_context(:research), do: 0.50

  @spec check_confidence(float(), float()) ::
          :ok | {:error, :confidence_insufficient, float()}
  defp check_confidence(confidence, threshold) when confidence >= threshold, do: :ok

  defp check_confidence(confidence, _threshold),
    do: {:error, :confidence_insufficient, confidence}
end

The ConfidenceMonitor provides real-time tracking of confidence scores as evidence accumulates:

defmodule PrismaticNabla.ConfidenceMonitor do
  @moduledoc """
  Monitors confidence scores for beliefs under investigation,
  automatically triggering transition evaluation when scores cross
  context-appropriate thresholds. Integrates with QEVE pipeline
  for calibrated confidence computation.
  """

  use GenServer

  @type confidence_event :: %{
          belief_id: String.t(),
          previous: float(),
          current: float(),
          threshold: float(),
          crossed: boolean(),
          timestamp: DateTime.t()
        }

  @spec compute(belief_id :: String.t()) :: {:ok, float()} | {:error, :not_found}
  def compute(belief_id) do
    GenServer.call(__MODULE__, {:compute, belief_id})
  end

  @spec subscribe(belief_id :: String.t()) :: :ok
  def subscribe(belief_id) do
    GenServer.call(__MODULE__, {:subscribe, belief_id})
  end

  @spec watch_threshold(belief_id :: String.t(), threshold :: float()) :: :ok
  def watch_threshold(belief_id, threshold) when threshold > 0.0 and threshold <= 1.0 do
    GenServer.call(__MODULE__, {:watch_threshold, belief_id, threshold})
  end

  @impl GenServer
  def handle_call({:compute, belief_id}, _from, state) do
    case compute_confidence(belief_id, state) do
      {:ok, score} = result ->
        new_state = update_score(state, belief_id, score)
        maybe_notify_threshold_crossing(state, belief_id, score)
        {:reply, result, new_state}

      {:error, _} = error ->
        {:reply, error, state}
    end
  end
end

Transition Anti-Patterns

The Transition Protocol defines five anti-patterns that represent common violations of transition discipline:

Anti-Pattern 1: Premature Execution

Description: Acting on a conclusion before the confidence threshold is met, typically driven by time pressure or organizational demands.

Detection: The ConfidenceMonitor logs every transition attempt with the current confidence score. Attempts where confidence is below threshold are flagged and counted. Repeated premature attempts for the same belief trigger an E2 investigation.

Example: An OSINT investigation identifies a potential sanctions match at 0.72 confidence. The analyst, under deadline pressure, attempts to mark the finding as verified. The Transition Protocol blocks the action: confidence 0.72 is below the 0.95 threshold for critical decisions. The system returns to exploration with a diagnostic indicating which evidence gaps reduce confidence.

Anti-Pattern 2: Analysis Paralysis

Description: Continuing exploration indefinitely despite having met all transition conditions, typically driven by risk aversion or perfectionism.

Detection: The ConfidenceMonitor tracks the duration of the exploration phase. When confidence has exceeded the threshold for a configurable period without transition being initiated, an advisory alert is raised. The alert does not force transition (only the formal conditions can do that) but signals that the evidence may already be sufficient.

Anti-Pattern 3: Threshold Manipulation

Description: Artificially lowering the confidence threshold or switching to a less strict context to trigger a transition that would not otherwise be authorized.

Detection: Context assignment is determined by the belief's classification at creation time, not at transition time. A belief classified as "critical" at creation cannot be reclassified as "exploratory" to reduce the threshold. Context reclassification requires supreme authority and a documented justification that is audited.

Anti-Pattern 4: Gate Shopping

Description: Re-evaluating the same belief repeatedly without new evidence, hoping for a different gate result.

Detection: The GateEvaluator caches results for each belief version. Re-evaluation with no new evidence returns the cached result immediately. The cache is invalidated only when new evidence is added to the belief graph.

Anti-Pattern 5: Partial Commitment

Description: Entering execution phase but hedging by maintaining exploration-phase behaviors (preserving "escape routes," maintaining alternative hypotheses).

Detection: Once in EXECUTING state, any attempt to add contradictory evidence, fork hypotheses, or reduce confidence is blocked. The NM/ND doctrine is absolute during execution. If new evidence genuinely invalidates the conclusion, a separate decision cycle must be initiated.

Integration with Platform Components

NABLA Infinity Integration

The Transition Protocol is the operational bridge between NABLA Infinity axioms and NM/ND doctrine. During exploration, NABLA governs all belief formation -- signals must be plural, contradictions preserved, provenance tracked, and uncertainty acknowledged. The Transition Protocol verifies that these axioms have been satisfied before authorizing the shift to execution mode.

Trinity Gate Integration

The Trinity Gate serves as the verification mechanism within the Transition Protocol. When the confidence threshold is crossed, the protocol triggers gate evaluation. The gate's structural, logical, and formal checks provide the independent verification that the confidence score alone cannot guarantee. A high confidence score from a structurally incoherent belief graph is still blocked.

Agent Integration

All 530+ AIAD agents in the platform operate under the Transition Protocol. When an agent's investigation reaches confidence threshold, the protocol is invoked automatically. Agents cannot bypass the protocol -- the evaluate_transition/2 call is embedded in the agent runtime's decision loop. This ensures that even the most specialized agents (OSINT collectors, security scanners, compliance evaluators) follow the same transition discipline.

Quality Gate Integration

The Transition Protocol shares conceptual DNA with the platform's quality gates. Both enforce the principle that no artifact (belief, code, decision) should proceed to the next phase without meeting explicit, verifiable criteria. The Transition Protocol is to epistemic decisions what quality gates are to software delivery -- a checkpoint that transforms subjective readiness into objective, measurable compliance.

Telemetry and Observability

The Transition Protocol emits telemetry events at every stage:

Event	Payload	Trigger
`[:prismatic_nabla, :transition, :threshold_crossed]`	belief_id, confidence, threshold, context	Confidence crosses threshold
`[:prismatic_nabla, :transition, :gate_evaluation_started]`	belief_id, context	Trinity Gate evaluation begins
`[:prismatic_nabla, :transition, :authorized]`	belief_id, confidence, gate_result, axiom_status	All conditions met
`[:prismatic_nabla, :transition, :blocked]`	belief_id, failed_condition, diagnostic	Any condition fails
`[:prismatic_nabla, :transition, :executing]`	belief_id, execution_plan	Execution phase begins
`[:prismatic_nabla, :transition, :completed]`	belief_id, outcome, duration	Decision cycle completes

These events feed into the platform's observability infrastructure, enabling real-time dashboards that show how many beliefs are in each phase, average time in exploration, transition success rates, and the most common failure modes across gate evaluations.

Formal Properties

The Transition Protocol satisfies several formally verified properties:

Safety: No belief transitions to execution without meeting all three conditions. Verified through property-based testing with 10,000+ generated evidence graphs.
Liveness: Any belief with sufficient evidence will eventually transition. The protocol does not create deadlocks -- if all conditions are met, the transition proceeds.
Determinism: The same evidence graph always produces the same transition decision. There is no randomness, no race condition, and no order dependence in the evaluation.
Irreversibility: Once in EXECUTING state, the belief cannot return to EXPLORING within the same decision cycle. This is enforced at the state machine level.
Independence: The three conditions are evaluated independently. A change in confidence does not affect gate evaluation, and gate evaluation does not affect axiom checking.

Real-World Application Example

Consider a due diligence investigation into a Czech company suspected of sanctions evasion. The investigation proceeds through the Transition Protocol:

Exploration Phase: The platform queries ARES, Justice.cz, the Insolvency Register, beneficial ownership databases, and international sanctions lists. Contradictory signals emerge -- the company's registered address matches a sanctioned entity's former address, but the beneficial ownership chain shows no direct connection. NABLA preserves both signals without resolution. Confidence computes to 0.68 (below the 0.95 threshold for critical decisions).

Evidence Accumulation: Additional sources are queried -- corporate registry historical snapshots, real estate ownership records, financial transaction patterns. The address match is explained by the building being a large commercial complex with hundreds of tenants. Confidence rises to 0.82, then 0.91 as the ownership chain is independently verified through three registry sources.

Threshold Crossing: A fourth independent source confirms the ownership structure. Confidence reaches 0.96, crossing the 0.95 threshold. The Transition Protocol automatically triggers gate evaluation.

Gate Evaluation: Structural check confirms the belief graph is a valid DAG with no circular reasoning. Logical check confirms all inference steps are sound and NABLA axioms are satisfied. Formal check constructs a Lean4 proof that the ownership chain is inconsistent with sanctions evasion given the evidence. Meta-integrity confirms gate independence.

Execution: All three conditions are met. The investigation transitions to execution. The No Mercy doctrine requires a complete, definitive assessment: the company is cleared of sanctions evasion with full evidence documentation and audit trail.

Comparison with Industry Approaches

Most decision-support systems use informal transition criteria -- an analyst decides when "enough" evidence has been gathered, or a fixed time limit forces a conclusion. These approaches fail in predictable ways:

Approach	Failure Mode	Transition Protocol Solution
Analyst judgment	Inconsistent thresholds across analysts	Mathematical confidence computation
Time-based deadline	Evidence sufficiency ignored	Threshold-based, not time-based
Majority vote	Minority evidence discarded	Contradiction preservation + signal plurality
Management override	Authority substitutes for evidence	Non-bypassable enforcement
Statistical threshold only	Structural incoherence ignored	Trinity Gate multi-layer verification

NABLA Infinity -- Epistemic framework governing the exploration phase
Trinity Gate -- 4-layer verification mechanism within the transition
Trinity Passage -- The act of successfully passing through Trinity Gate
Confidence Threshold -- Context-dependent score requirements
Confidence Scoring -- Calibrated probability computation
No Mercy, No Doubts -- Execution doctrine activated after transition
No Mercy -- Execution-phase enforcement of complete delivery
Signal Plurality -- NABLA axiom requiring multiple independent signals
Contradiction Preservation -- NABLA axiom preserving contradictory evidence
Axiom Enforcement -- Runtime enforcement of NABLA axioms
Epistemic Pipeline -- 16-level pipeline where transition operates
Formal Verification -- Verification methodology powering Gate 3
Tactical Execution -- Execution patterns after transition
Quality Gate -- Analogous concept in software delivery

Connect & Contribute

Created by Tomas Korcak (korczis) | Open Source under GHL

GitHub | GitLab | LinkedIn | Contact
Developer Portal | Architecture | Meet the Creator

Transition Protocol