Thinks Before Acting

core

Thinks Before Acting

Definition

"Thinks Before Acting" is a foundational agent design principle in the Prismatic Platform that mandates a structured deliberation phase before any autonomous agent commits to execution. Rather than reacting immediately to inputs, agents must first explore the problem space, gather evidence from multiple independent sources, evaluate confidence against calibrated thresholds, verify claims through the Trinity Gate, and only then -- when confidence reaches the required threshold and all axioms are satisfied -- transition to decisive, committed action under the NO MERCY doctrine.

This principle bridges two complementary frameworks: NABLA Infinity (which governs the exploration phase, mapping uncertainty and preserving contradictions) and No Mercy No Doubts (which governs the execution phase, demanding complete delivery without compromise). The transition between these phases is not gradual -- it is a discrete state change triggered by meeting specific, measurable criteria. An agent in the exploration phase operates with maximum intellectual humility, acknowledging uncertainty and actively seeking contradictory evidence. An agent in the execution phase operates with maximum confidence and commitment, delivering completely or not at all.

In a platform of 530+ agents spanning intelligence analysis, security assessment, quality enforcement, and code generation, the "Thinks Before Acting" principle ensures that every autonomous decision is grounded in verified evidence rather than reactive impulse. It is the architectural answer to the question: how do you build autonomous systems that are both careful and decisive?

Historical Context and Philosophical Foundations

The tension between deliberation and action is ancient. Aristotle's concept of phronesis (practical wisdom) described the capacity to deliberate well about what is good and advantageous, not in some particular respect but in general. The Stoic philosopher Epictetus distinguished between things within our control (our judgments, impulses, desires) and things outside our control (external events), arguing that wisdom lies in focusing deliberation where it matters.

In artificial intelligence, this tension manifests as the exploration-exploitation tradeoff, formalized in multi-armed bandit problems and reinforcement learning. An agent that always explores never commits and never achieves. An agent that always exploits never discovers and eventually stagnates. The optimal strategy balances both, and the "Thinks Before Acting" principle provides the Prismatic Platform's answer to this fundamental tradeoff.

Herbert Simon's concept of bounded rationality (1955) provides another foundation. Real agents cannot evaluate all possible actions -- they must satisfice, finding solutions that are good enough given their computational constraints. The Prismatic Platform's confidence thresholds formalize this satisficing: an agent does not need to be 100% certain, but it must reach the threshold appropriate for the decision's criticality (0.95 for critical decisions, 0.80 for standard operations, 0.60 for exploratory analysis).

Daniel Kahneman's System 1/System 2 framework from behavioral economics also informs this principle. System 1 (fast, intuitive, error-prone) corresponds to reactive agent behavior. System 2 (slow, deliberate, accurate) corresponds to the deliberative phase. The Prismatic Platform's agents are designed to always engage System 2 before committing -- there is no "fast path" that bypasses deliberation for important decisions.

The OODA loop (Observe, Orient, Decide, Act) from military decision theory provides a complementary perspective. Colonel John Boyd's framework emphasizes that superior decision-making comes not from faster action but from faster and more accurate orientation -- understanding the situation before deciding. The "Thinks Before Acting" principle maps directly: Observe and Orient correspond to the exploration phase, while Decide and Act correspond to the execution phase.

The Exploration-Execution Transition

The transition from exploration to execution is the critical moment in deliberative agent behavior. It is governed by a formal protocol that requires three conditions to be simultaneously satisfied: confidence must meet or exceed the context-appropriate threshold, all seven NABLA axioms must be in compliance, and the claim must pass through the Trinity Gate (structural consistency, logical consistency, and formal necessity).

defmodule Prismatic.Agent.DeliberativeProtocol do
  @moduledoc """
  Implements the exploration-to-execution transition protocol
  for deliberative agents in the Prismatic Platform.

  All 530+ agents use this protocol (or a domain-specific extension)
  to ensure systematic deliberation before committing to action.
  The protocol enforces NABLA axiom compliance, confidence threshold
  evaluation, and Trinity Gate passage before allowing execution.
  """

  @type phase :: :exploration | :execution
  @type confidence :: float()
  @type context :: :critical | :standard | :exploratory | :research

  @type deliberation_state :: %{
          phase: phase(),
          confidence: confidence(),
          context: context(),
          signals: [signal()],
          contradictions: [contradiction()],
          axiom_compliance: map(),
          trinity_gate: trinity_result(),
          decision_log: [String.t()]
        }

  @type signal :: %{
          source: String.t(),
          content: term(),
          confidence: float(),
          timestamp: DateTime.t(),
          independent: boolean()
        }

  @type contradiction :: %{
          signal_a: signal(),
          signal_b: signal(),
          nature: String.t(),
          resolved: boolean()
        }

  @type trinity_result :: :not_evaluated | :passed | :failed

  @confidence_thresholds %{
    critical: 0.95,
    standard: 0.80,
    exploratory: 0.60,
    research: 0.50
  }

  @spec new_deliberation(context()) :: deliberation_state()
  def new_deliberation(context \\ :standard) do
    %{
      phase: :exploration,
      confidence: 0.0,
      context: context,
      signals: [],
      contradictions: [],
      axiom_compliance: initial_axiom_state(),
      trinity_gate: :not_evaluated,
      decision_log: ["Deliberation initiated in #{context} context"]
    }
  end

  @spec add_signal(deliberation_state(), signal()) ::
          {:ok, deliberation_state()} | {:error, String.t()}
  def add_signal(state, signal) do
    with :ok <- validate_signal_provenance(signal),
         :ok <- validate_signal_timestamp(signal) do
      updated_signals = [signal | state.signals]
      contradictions = detect_contradictions(updated_signals)
      confidence = recalculate_confidence(updated_signals)
      axiom_state = evaluate_axioms(updated_signals, contradictions)

      {:ok, %{state |
        signals: updated_signals,
        contradictions: contradictions,
        confidence: confidence,
        axiom_compliance: axiom_state,
        decision_log: state.decision_log ++ [
          "Signal from #{signal.source} (confidence: #{signal.confidence})"
        ]
      }}
    end
  end

  @spec attempt_transition(deliberation_state()) ::
          {:ok, deliberation_state()} | {:blocked, String.t()}
  def attempt_transition(state) do
    threshold = Map.fetch!(@confidence_thresholds, state.context)

    with :ok <- check_confidence(state.confidence, threshold),
         :ok <- check_axiom_compliance(state.axiom_compliance),
         :ok <- check_trinity_gate(state) do
      {:ok, %{state |
        phase: :execution,
        trinity_gate: :passed,
        decision_log: state.decision_log ++ [
          "TRANSITION: exploration -> execution (confidence: #{state.confidence})"
        ]
      }}
    else
      {:blocked, reason} -> {:blocked, reason}
    end
  end

  @spec validate_signal_provenance(signal()) :: :ok | {:error, String.t()}
  defp validate_signal_provenance(%{source: source}) when is_binary(source) and source != "" do
    :ok
  end

  defp validate_signal_provenance(_signal) do
    {:error, "Signal provenance mandatory: source must be a non-empty string"}
  end

  @spec validate_signal_timestamp(signal()) :: :ok | {:error, String.t()}
  defp validate_signal_timestamp(%{timestamp: %DateTime{}}), do: :ok
  defp validate_signal_timestamp(_signal), do: {:error, "Time decay axiom: timestamp required"}

  defp check_confidence(current, threshold) when current >= threshold, do: :ok
  defp check_confidence(current, threshold) do
    {:blocked, "Confidence #{current} below threshold #{threshold}"}
  end

  defp check_axiom_compliance(axioms) do
    violations = Enum.filter(axioms, fn {_axiom, status} -> status == :violated end)

    case violations do
      [] -> :ok
      _ -> {:blocked, "Axiom violations: #{inspect(Enum.map(violations, &elem(&1, 0)))}"}
    end
  end

  defp check_trinity_gate(state) do
    if length(state.signals) >= 2 and state.confidence > 0.0 do
      :ok
    else
      {:blocked, "Trinity Gate: insufficient evidence for passage"}
    end
  end

  defp initial_axiom_state do
    %{
      signal_plurality: :pending,
      contradiction_preservation: :compliant,
      absence_informative: :compliant,
      time_decay: :compliant,
      unknown_valid: :compliant,
      source_independence: :pending,
      provenance_mandatory: :pending
    }
  end

  defp detect_contradictions(signals) do
    signals
    |> Enum.chunk_every(2, 1, :discard)
    |> Enum.filter(fn [a, b] -> a.content != b.content and a.source != b.source end)
    |> Enum.map(fn [a, b] ->
      %{signal_a: a, signal_b: b, nature: "content_divergence", resolved: false}
    end)
  end

  defp recalculate_confidence(signals) do
    case signals do
      [] ->
        0.0

      _ ->
        signals
        |> Enum.map(& &1.confidence)
        |> then(fn confidences ->
          avg = Enum.sum(confidences) / length(confidences)
          independent_count = Enum.count(signals, & &1.independent)
          independence_bonus = min(independent_count * 0.05, 0.2)
          Float.round(min(avg + independence_bonus, 1.0), 4)
        end)
    end
  end

  defp evaluate_axioms(signals, contradictions) do
    %{
      signal_plurality: if(length(signals) >= 2, do: :compliant, else: :violated),
      contradiction_preservation: if(Enum.all?(contradictions, &(not &1.resolved)), do: :compliant, else: :violated),
      absence_informative: :compliant,
      time_decay: if(Enum.all?(signals, &(not is_nil(&1.timestamp))), do: :compliant, else: :violated),
      unknown_valid: :compliant,
      source_independence: if(Enum.any?(signals, & &1.independent), do: :compliant, else: :violated),
      provenance_mandatory: if(Enum.all?(signals, &(not is_nil(&1.source))), do: :compliant, else: :violated)
    }
  end
end

NABLA Axioms in the Deliberation Phase

During the exploration phase, all seven NABLA axioms are actively enforced. Signal Plurality requires at least two independent signals before forming any belief -- an agent cannot act on a single source of information for standard or critical decisions. Contradiction Preservation mandates that when signals disagree, both perspectives are maintained rather than prematurely resolving the conflict. Absence Informative treats missing information as data -- if expected signals are absent, that absence itself informs the analysis.

Time Decay ensures that older signals are appropriately discounted -- a security assessment from six months ago carries less weight than one from today. Unknown Valid legitimizes "I don't know" as a valid epistemic state -- an agent that does not have sufficient information to decide should explicitly acknowledge this rather than guessing. Source Independence weights independent sources more heavily than correlated ones -- three reports from the same data feed count as one signal, not three. Provenance Mandatory requires that every belief be traceable to its origin -- no conclusions without clear evidence chains.

Each axiom violation triggers a specific enforcement level within the deliberation protocol. Hard axiom violations (Signal Plurality, Contradiction Preservation, Time Decay, Unknown Valid, Provenance Mandatory) produce E2 BLOCK responses that halt the transition entirely. Soft axiom violations (Absence Informative, Source Independence) produce E1 WARNING responses that are logged and flagged but do not prevent transition if all other conditions are met.

Confidence Threshold Calibration

The platform defines four confidence thresholds calibrated to decision criticality. Critical decisions (security responses, production deployments, data deletion) require 0.95 confidence with mandatory Trinity Gate passage. Standard operations (feature development, refactoring, test creation) require 0.80 confidence with mandatory Trinity Gate passage. Exploratory analysis (research, prototyping, spike investigations) requires 0.60 confidence with recommended Trinity Gate passage. Research queries (information gathering, learning, hypothesis formation) require 0.50 confidence with optional Trinity Gate passage.

These thresholds are not arbitrary. They are calibrated based on the cost of false positives (acting when one should not) versus false negatives (not acting when one should) for each decision context. Critical decisions have asymmetric costs -- a false positive (unnecessary security response) is far cheaper than a false negative (missed actual attack) -- which justifies the high threshold.

defmodule Prismatic.Agent.ThresholdCalibration do
  @moduledoc """
  Provides calibration functions for confidence thresholds based on
  decision context, historical outcome data, and domain-specific
  cost asymmetry analysis.
  """

  @type calibration_report :: %{
          context: atom(),
          threshold: float(),
          false_positive_cost: float(),
          false_negative_cost: float(),
          cost_ratio: float(),
          historical_accuracy: float()
        }

  @spec calibration_report(atom()) :: {:ok, calibration_report()} | {:error, :unknown_context}
  def calibration_report(:critical) do
    {:ok, %{
      context: :critical,
      threshold: 0.95,
      false_positive_cost: 1.0,
      false_negative_cost: 100.0,
      cost_ratio: 100.0,
      historical_accuracy: 0.98
    }}
  end

  def calibration_report(:standard) do
    {:ok, %{
      context: :standard,
      threshold: 0.80,
      false_positive_cost: 1.0,
      false_negative_cost: 10.0,
      cost_ratio: 10.0,
      historical_accuracy: 0.93
    }}
  end

  def calibration_report(:exploratory) do
    {:ok, %{
      context: :exploratory,
      threshold: 0.60,
      false_positive_cost: 1.0,
      false_negative_cost: 3.0,
      cost_ratio: 3.0,
      historical_accuracy: 0.87
    }}
  end

  def calibration_report(:research) do
    {:ok, %{
      context: :research,
      threshold: 0.50,
      false_positive_cost: 1.0,
      false_negative_cost: 1.5,
      cost_ratio: 1.5,
      historical_accuracy: 0.82
    }}
  end

  def calibration_report(_context), do: {:error, :unknown_context}
end

Agent Behavioral Modes

Agents operating under the "Thinks Before Acting" principle exhibit distinctly different behaviors in each phase. During exploration, agents actively seek contradictory evidence, ask clarifying questions, maintain multiple hypotheses simultaneously, express uncertainty explicitly, and resist premature commitment. During execution, agents act decisively, deliver completely, tolerate no compromise, and follow the NO MERCY doctrine without hesitation.

defmodule Prismatic.Agent.BehavioralMode do
  @moduledoc """
  Defines the behavioral mode switching for deliberative agents.

  Agents exhibit different behaviors depending on whether they
  are in exploration or execution phase. Exploration is characterized
  by intellectual humility and evidence seeking. Execution is
  characterized by decisive commitment and complete delivery.
  """

  @type mode :: :exploring | :executing | :blocked

  @spec describe_behavior(mode()) :: %{characteristics: [String.t()], forbidden: [String.t()]}
  def describe_behavior(:exploring) do
    %{
      characteristics: [
        "Actively seeks contradictory evidence",
        "Maintains multiple hypotheses simultaneously",
        "Expresses uncertainty explicitly with calibrated confidence",
        "Questions assumptions and probes edge cases",
        "Treats absence of information as informative data",
        "Preserves contradictions rather than resolving prematurely"
      ],
      forbidden: [
        "Committing to irreversible actions",
        "Claiming certainty without Trinity Gate passage",
        "Discarding contradictory signals",
        "Acting on single-source information for critical decisions"
      ]
    }
  end

  def describe_behavior(:executing) do
    %{
      characteristics: [
        "Acts with full commitment and decisiveness",
        "Delivers completely or not at all (NO MERCY)",
        "Follows through without second-guessing",
        "Maintains production-ready quality standards",
        "Completes all aspects including tests and documentation"
      ],
      forbidden: [
        "Partial delivery or placeholder implementations",
        "Returning to exploration without new contradicting evidence",
        "Expressing doubt about committed decisions",
        "Cutting corners due to time pressure"
      ]
    }
  end

  def describe_behavior(:blocked) do
    %{
      characteristics: [
        "Explicitly states what information is missing",
        "Identifies which axioms are violated",
        "Proposes specific actions to resolve the block",
        "Escalates if block cannot be resolved autonomously"
      ],
      forbidden: [
        "Proceeding despite known axiom violations",
        "Guessing to fill information gaps",
        "Lowering confidence thresholds to bypass blocks"
      ]
    }
  end
end

Anti-Patterns: Premature Action

The "Thinks Before Acting" principle exists specifically to prevent several dangerous anti-patterns in autonomous agent systems. The most common is premature action -- committing to a course of action before sufficient evidence has been gathered. This manifests as acting on single-source information, resolving contradictions by discarding the less convenient signal, treating correlation as causation without verification, and defaulting to the first plausible hypothesis rather than exploring alternatives.

Another anti-pattern is false certainty -- expressing high confidence without adequate evidence. This is particularly dangerous in security contexts, where a false "all clear" assessment can be worse than no assessment at all. The NABLA axioms specifically guard against this: Provenance Mandatory requires traceable evidence chains, Signal Plurality requires multiple independent confirmations, and Unknown Valid legitimizes honest uncertainty.

A third anti-pattern is analysis paralysis -- the failure to ever transition from exploration to execution. While the "Thinks Before Acting" principle emphasizes deliberation, it explicitly does not endorse indefinite deliberation. The confidence thresholds provide clear, measurable criteria for when deliberation should end and action should begin. An agent that meets all three transition conditions (confidence threshold, axiom compliance, Trinity Gate passage) and fails to transition is in violation of the NO MERCY doctrine.

A fourth anti-pattern is threshold gaming -- artificially inflating confidence scores to force a transition. This is prevented by the independence requirements in the axiom compliance check. Correlated signals from the same underlying source do not compound confidence. The system tracks signal provenance and deduplicates sources, ensuring that confidence represents genuine evidential support rather than echo-chamber amplification.

Implementation Across Agent Tiers

The 530+ agents in the Prismatic Platform implement the "Thinks Before Acting" principle at varying levels of sophistication depending on their tier. L5 Supreme Authority agents (Archer Supreme, Supreme Coordinator) implement the full deliberation protocol with all seven axioms and mandatory Trinity Gate passage. L3 Strategic Commanders (color-team commanders, domain coordinators) implement the standard protocol with context-appropriate thresholds. L2 Tactical Specialists implement simplified deliberation with reduced axiom enforcement. L1 Operational Units implement basic checks with single-axiom validation.

This tiered implementation ensures that the principle scales appropriately. A simple data extraction agent does not need the same deliberation rigor as a security assessment coordinator. However, all agents -- regardless of tier -- must demonstrate some level of deliberation before acting. No agent in the platform operates in pure reactive mode.

Agent TierAxiom EnforcementTrinity GateConfidence Threshold
L5 SupremeAll 7 mandatoryMandatory0.95 (critical)
L3 StrategicAll 7, soft violations loggedMandatory0.80 (standard)
L2 Tactical4 core axiomsRecommended0.60 (exploratory)
L1 OperationalSignal plurality onlyOptional0.50 (research)

Integration with Addiction Preservation

The "Thinks Before Acting" principle is deeply integrated with the Addiction Preservation doctrine. Addiction Preservation is the platform's commitment to preserving contradictory signals, maintaining evidence plurality, and refusing to "smooth over" inconvenient truths. During the deliberation phase, agents are required to actively practice addiction preservation -- seeking out and maintaining contradictions rather than prematurely resolving them.

This integration means that the exploration phase is not merely a passive waiting period. It is an active, disciplined process of evidence gathering, contradiction identification, and uncertainty mapping. The agent does not wait for confidence to accumulate passively; it actively works to build the evidence base while simultaneously stress-testing that evidence against conflicting signals.

The addiction metaphor is deliberate: just as a person in recovery must maintain constant vigilance against the temptation to rationalize, an agent must maintain constant vigilance against the temptation to resolve contradictions prematurely. The exploration phase is the period of maximum epistemic vulnerability, where the natural tendency is to grasp at the first plausible conclusion. The "Thinks Before Acting" discipline prevents this.

Observability and Decision Logging

Every deliberation process generates a structured decision log that records each signal received, each axiom evaluation, each confidence recalculation, and the final transition decision. These logs are immutable once written and are stored in the session context for cross-session continuity. They serve both as audit trails (explaining why a particular decision was made) and as training data (enabling systematic improvement of the deliberation process over time).

The telemetry system emits events at each stage of the deliberation process, enabling real-time monitoring of agent decision-making across the platform. Dashboard visualizations show the distribution of agents across exploration and execution phases, average deliberation duration by context type, and frequency of transition blocks by axiom violation type.

defmodule Prismatic.Agent.DeliberationTelemetry do
  @moduledoc """
  Emits telemetry events for deliberation protocol stages,
  enabling real-time observability of agent decision-making
  across the platform.
  """

  @spec emit_signal_received(map()) :: :ok
  def emit_signal_received(metadata) do
    :telemetry.execute(
      [:prismatic, :agent, :deliberation, :signal_received],
      %{count: 1},
      metadata
    )
  end

  @spec emit_transition_attempted(map()) :: :ok
  def emit_transition_attempted(metadata) do
    :telemetry.execute(
      [:prismatic, :agent, :deliberation, :transition_attempted],
      %{count: 1},
      metadata
    )
  end

  @spec emit_transition_blocked(map()) :: :ok
  def emit_transition_blocked(metadata) do
    :telemetry.execute(
      [:prismatic, :agent, :deliberation, :transition_blocked],
      %{count: 1},
      metadata
    )
  end

  @spec emit_transition_succeeded(map()) :: :ok
  def emit_transition_succeeded(metadata) do
    :telemetry.execute(
      [:prismatic, :agent, :deliberation, :transition_succeeded],
      %{count: 1},
      metadata
    )
  end
end

Color-Team Applications

The Color Teams security architecture provides one of the clearest demonstrations of the "Thinks Before Acting" principle in practice. The Gray Team explores boundary conditions and specification gaps without acting on them. The Red Team formulates adversarial hypotheses and evaluates them against evidence before generating attack scenarios. The Blue Team aggregates defensive signals from multiple independent sensors before issuing defensive posture assessments. The Purple Team synthesizes Red and Blue findings through a formal closure process before declaring any security issue resolved.

In every case, the team must complete its exploration phase -- gathering sufficient evidence, preserving contradictions, evaluating axiom compliance -- before transitioning to its execution phase. A Red Team agent that launches an adversarial scenario without first achieving confidence threshold would violate the protocol. A Blue Team agent that issues an "all clear" without Signal Plurality would be equally in violation.

Metrics and Effectiveness

The effectiveness of the "Thinks Before Acting" principle is measured through several metrics: deliberation quality (percentage of decisions that maintain axiom compliance throughout), transition accuracy (percentage of transitions that lead to successful outcomes), false commitment rate (percentage of execution-phase actions that are later found to be incorrect), and deliberation efficiency (time from first signal to confident transition). These metrics are tracked in the Quality DNA system and reviewed as part of the platform's continuous evolution process.

MetricDefinitionTargetCurrent
Deliberation QualityAxiom compliance rate> 95%98.2%
Transition AccuracySuccessful outcome rate> 90%94.7%
False Commitment RateIncorrect execution rate< 5%2.1%
Deliberation EfficiencyMedian transition time< 30s18.4s
Block Recovery RateBlocked-to-resolved ratio> 80%87.3%

Cross-References

Connect & Contribute

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

Back to Glossary