Definition

Autonomous Decision Making is the capacity of an AI system, agent, or software component to evaluate conditions, weigh alternatives, and commit to a course of action independently -- without requiring human approval for each individual decision. The critical distinction from simple automation is that autonomous decision making involves genuine evaluation under uncertainty: the system encounters situations it has not been explicitly programmed to handle and must reason about the appropriate response within defined authority boundaries.

In the Prismatic Platform, autonomous decision making is not unbounded. Every agent operates within a defined authority scope determined by its Agent Tier and Authority Level. Decisions that exceed an agent's authority are escalated to higher-tier agents or flagged for human review. This bounded autonomy model ensures that the platform can operate at machine speed for routine decisions while maintaining human oversight for consequential ones.

Overview

The concept of autonomous decision making in software systems has evolved significantly from early expert systems through modern AI agent architectures. Early approaches encoded decision logic as rigid rule trees -- effective for narrow domains but brittle when encountering novel situations. Modern approaches, as implemented in the Prismatic Platform, combine structured authority hierarchies with epistemic confidence scoring to create systems that know both what they can decide and how confident they are in each decision.

The Prismatic Platform's approach to autonomous decision making rests on three pillars:

Authority Boundaries -- Each agent has a formally defined scope of decisions it may make autonomously, determined by its tier level (L1 through L5).
Confidence Gating -- Decisions proceed only when the agent's confidence in the correct outcome exceeds a context-dependent threshold, enforced through the NABLA Infinity framework.
Audit Provenance -- Every autonomous decision is logged with full provenance: the inputs considered, the alternatives evaluated, the confidence score, and the authority level invoked.

This architecture enables 530+ agents to operate concurrently, each making hundreds of decisions per session, while maintaining the epistemic rigor demanded by the No Mercy, No Doubts doctrine.

Technical Details

Authority Hierarchy

The Prismatic Platform implements a five-level authority hierarchy that governs autonomous decision scope:

Tier	Authority Scope	Decision Examples	Escalation Target
L5 (Supreme)	Platform-wide strategic decisions	Architecture changes, doctrine modifications, generation advancement	Human review
L4 (Specialist)	Domain-scoped operational decisions	Quality gate enforcement, safety validation, escalation guarding	L5 Supreme
L3 (Commander)	Team-scoped tactical decisions	Agent orchestration, campaign management, resource allocation	L4 Specialist or L5
L2 (Tactical)	Task-scoped execution decisions	Code analysis, pattern detection, test execution	L3 Commander
L1 (Operative)	Atomic operation decisions	File reading, metric collection, status reporting	L2 Tactical

Decision Engine Architecture

The decision engine operates as a GenServer that receives decision requests, evaluates them against authority boundaries and confidence thresholds, and either executes or escalates:

defmodule Prismatic.Agents.DecisionEngine do
  @moduledoc """
  Core decision engine for autonomous agent decision making.
  Evaluates requests against authority boundaries and confidence
  thresholds before committing to execution or escalation.
  """

  use GenServer

  alias Prismatic.Agents.AuthorityBoundary
  alias Prismatic.Agents.ConfidenceScorer
  alias Prismatic.Agents.DecisionAudit

  @type decision_request :: %{
    agent_id: String.t(),
    agent_tier: 1..5,
    action: atom(),
    context: map(),
    domain: atom()
  }

  @type decision_result ::
    {:ok, :executed, map()}
    | {:ok, :escalated, map()}
    | {:error, :authority_violation, String.t()}
    | {:error, :confidence_insufficient, float()}

  @spec decide(decision_request()) :: decision_result()
  def decide(%{agent_id: agent_id, agent_tier: tier, action: action} = request) do
    with {:ok, boundary} <- AuthorityBoundary.resolve(tier, action),
         {:ok, confidence} <- ConfidenceScorer.evaluate(request),
         :ok <- validate_threshold(confidence, boundary.required_confidence) do
      result = execute_decision(request, boundary)
      DecisionAudit.log(agent_id, request, result, confidence)
      {:ok, :executed, result}
    else
      {:error, :out_of_scope} ->
        escalation = escalate_decision(request)
        DecisionAudit.log(agent_id, request, escalation, 0.0)
        {:ok, :escalated, escalation}

      {:error, :confidence_below_threshold, score} ->
        DecisionAudit.log(agent_id, request, :deferred, score)
        {:error, :confidence_insufficient, score}
    end
  end

  @spec validate_threshold(float(), float()) :: :ok | {:error, :confidence_below_threshold, float()}
  defp validate_threshold(confidence, threshold) when confidence >= threshold, do: :ok
  defp validate_threshold(confidence, _threshold), do: {:error, :confidence_below_threshold, confidence}

  @spec execute_decision(decision_request(), AuthorityBoundary.t()) :: map()
  defp execute_decision(request, boundary) do
    action_module = boundary.action_module
    action_module.execute(request.context)
  end

  @spec escalate_decision(decision_request()) :: map()
  defp escalate_decision(%{agent_tier: tier} = request) do
    escalation_tier = min(tier + 1, 5)
    %{escalated_to: escalation_tier, reason: :authority_exceeded, original_request: request}
  end
end

Confidence Scoring Integration

Autonomous decisions are gated by confidence scores derived from the NABLA Infinity epistemic framework. The confidence score reflects the system's assessment of how likely a decision is to be correct, given available evidence:

defmodule Prismatic.Agents.ConfidenceScorer do
  @moduledoc """
  Evaluates confidence in a proposed decision using NABLA Infinity
  epistemic axioms: signal plurality, contradiction preservation,
  and provenance tracking.
  """

  @spec evaluate(map()) :: {:ok, float()} | {:error, :insufficient_signals}
  def evaluate(%{context: context, action: action}) do
    signals = collect_signals(context, action)

    case length(signals) do
      n when n < 2 ->
        # NABLA axiom: Signal Plurality requires minimum 2 signals
        {:error, :insufficient_signals}

      _ ->
        score = calculate_composite_confidence(signals)
        {:ok, score}
    end
  end

  @spec calculate_composite_confidence([map()]) :: float()
  defp calculate_composite_confidence(signals) do
    agreement = signal_agreement_ratio(signals)
    independence = source_independence_factor(signals)
    recency = time_decay_factor(signals)

    agreement * 0.50 + independence * 0.30 + recency * 0.20
  end

  @spec signal_agreement_ratio([map()]) :: float()
  defp signal_agreement_ratio(signals) do
    {supporting, total} = Enum.reduce(signals, {0, 0}, fn signal, {sup, tot} ->
      if signal.supports_action, do: {sup + 1, tot + 1}, else: {sup, tot + 1}
    end)

    if total > 0, do: supporting / total, else: 0.0
  end

  @spec source_independence_factor([map()]) :: float()
  defp source_independence_factor(signals) do
    unique_sources = signals |> Enum.map(& &1.source) |> Enum.uniq() |> length()
    total = length(signals)
    if total > 0, do: unique_sources / total, else: 0.0
  end

  @spec time_decay_factor([map()]) :: float()
  defp time_decay_factor(signals) do
    now = System.monotonic_time(:second)
    signals
    |> Enum.map(fn s -> :math.exp(-0.001 * (now - s.timestamp)) end)
    |> then(fn scores -> Enum.sum(scores) / length(scores) end)
  end

  @spec collect_signals(map(), atom()) :: [map()]
  defp collect_signals(context, action) do
    # Gather signals from multiple independent sources
    [
      context_signals(context),
      historical_signals(action),
      quality_gate_signals(context)
    ]
    |> List.flatten()
  end

  defp context_signals(context), do: Map.get(context, :signals, [])
  defp historical_signals(action), do: Prismatic.Agents.History.signals_for(action)
  defp quality_gate_signals(context), do: Prismatic.Quality.Gates.signals(context)
end

Confidence Thresholds by Context

Decision Context	Required Confidence	Trinity Gate	Rationale
Critical (architecture, security)	0.95	MANDATORY	Irreversible or high-impact decisions
Standard (code changes, refactoring)	0.80	MANDATORY	Reversible but consequential decisions
Exploratory (analysis, scanning)	0.60	RECOMMENDED	Low-risk information gathering
Research (hypothesis generation)	0.50	OPTIONAL	Speculative investigation

Decision Audit Trail

Every autonomous decision produces an immutable audit record:

defmodule Prismatic.Agents.DecisionAudit do
  @moduledoc """
  Immutable audit trail for all autonomous decisions.
  Provides full provenance tracing as required by NABLA
  axiom 7 (Provenance Mandatory).
  """

  @spec log(String.t(), map(), term(), float()) :: {:ok, String.t()}
  def log(agent_id, request, result, confidence) do
    record = %{
      id: generate_audit_id(),
      timestamp: DateTime.utc_now(),
      agent_id: agent_id,
      agent_tier: request.agent_tier,
      action: request.action,
      domain: request.domain,
      confidence_score: confidence,
      result_type: classify_result(result),
      inputs_hash: hash_inputs(request.context),
      provenance_chain: build_provenance(request),
      trinity_gate_status: trinity_status(request)
    }

    {:ok, _} = Prismatic.Storage.append(:decision_audit, record)
    {:ok, record.id}
  end

  @spec classify_result(term()) :: atom()
  defp classify_result({:ok, :executed, _}), do: :executed
  defp classify_result({:ok, :escalated, _}), do: :escalated
  defp classify_result(:deferred), do: :deferred
  defp classify_result(_), do: :unknown

  defp generate_audit_id, do: "dec_" <> Base.encode16(:crypto.strong_rand_bytes(8))
  defp hash_inputs(context), do: :crypto.hash(:sha256, :erlang.term_to_binary(context))
  defp build_provenance(request), do: %{source: request.agent_id, chain: [request.domain]}
  defp trinity_status(%{domain: :critical}), do: :mandatory
  defp trinity_status(_), do: :standard
end

Implementation in Prismatic Platform

Agent Tier Decision Scope

The Prismatic Platform's 530+ agents operate across five tiers, each with precisely defined autonomous decision scope:

L5 Supreme Agents (e.g., archer-supreme, supreme-coordinator): Make platform-wide strategic decisions including generation advancement, doctrine interpretation, and cross-domain coordination. These agents can autonomously trigger architectural changes when confidence exceeds 0.95 and all three Trinity Gate conditions pass.

L4 Specialist Agents (e.g., gray-escalation-guard, purple-regression-guard): Make domain-scoped operational decisions. The Gray Escalation Guard, for instance, autonomously decides whether a Gray Team finding should be escalated to Red Team for adversarial simulation -- a decision that requires evaluating the finding's severity, novelty, and potential impact.

L3 Commander Agents (e.g., red-commander, blue-commander, purple-coordinator): Make team-scoped tactical decisions. The Red Commander autonomously selects which adversarial scenarios to execute based on the current platform posture, available resources, and Purple Team feedback.

L2 Tactical Agents (e.g., red-epistemic-attacker, blue-drift-detector): Make task-scoped execution decisions. These agents autonomously decide how to execute their assigned tasks -- which techniques to apply, what order to process items, when to report findings.

L1 Operative Agents: Make atomic operation decisions -- reading files, collecting metrics, formatting output. These decisions require minimal confidence and no escalation.

NABLA Integration

The NABLA Infinity framework governs the epistemic quality of autonomous decisions through seven non-negotiable axioms:

NABLA Axiom	Decision Impact
Signal Plurality	No decision proceeds with fewer than 2 independent signals
Contradiction Preservation	Conflicting signals are preserved and reported, never suppressed
Absence Informative	Missing expected signals are treated as data points, not ignored
Time Decay	Older signals receive lower weight in confidence calculation
Unknown Valid	"I don't know" is a valid decision outcome
Source Independence	Signals from independent sources receive higher weight
Provenance Mandatory	Every decision must be traceable to its input signals

Decision Flow Architecture

Agent receives task
    |
    v
Evaluate authority boundary (tier check)
    |
    +-- Out of scope --> Escalate to higher tier
    |
    v
Collect signals (minimum 2 per NABLA)
    |
    +-- Insufficient signals --> Defer (request more data)
    |
    v
Calculate confidence score
    |
    +-- Below threshold --> Defer or escalate
    |
    v
Check Trinity Gate (if required by context)
    |
    +-- Gate fails --> HALT, escalate to Supreme
    |
    v
Execute decision
    |
    v
Log audit record (immutable)
    |
    v
Report outcome to caller

Comparison with Alternatives

Autonomous vs. Automated Decision Making

Dimension	Autonomous Decision Making	Automated Decision Making
Flexibility	Handles novel situations through reasoning	Follows predetermined rules for known situations
Uncertainty	Operates under uncertainty with confidence scoring	Requires deterministic inputs
Scope	Dynamic, bounded by authority level	Static, bounded by rule set
Adaptability	Learns from outcomes, adjusts approach	Follows fixed logic regardless of outcomes
Auditability	Full epistemic provenance chain	Simple input-output mapping
Risk	Higher (novel decisions may be wrong)	Lower (predictable but limited)
Use Case	Agent orchestration, security assessment	CI/CD pipelines, quality gates

Comparison with Industry Approaches

Platform	Approach	Prismatic Difference
LangChain Agents	Tool-use with LLM reasoning	Prismatic adds formal authority tiers and NABLA confidence gating
AutoGPT	Unbounded autonomous loop	Prismatic enforces strict authority boundaries and escalation
CrewAI	Role-based agent collaboration	Prismatic adds epistemic verification through Trinity Gate
Microsoft AutoGen	Multi-agent conversation	Prismatic adds formal confidence thresholds and audit provenance
OpenAI Assistants	Function calling with guardrails	Prismatic adds multi-level authority hierarchy and NABLA axioms

The key differentiator is Prismatic's integration of formal epistemic verification (NABLA + Trinity Gate) with hierarchical authority boundaries. Most agent frameworks allow either unbounded autonomy or rigid rule-following; Prismatic occupies the middle ground of principled bounded autonomy.

Best Practices

Designing Authority Boundaries

Start restrictive, widen carefully -- New agents should begin at L1 or L2 and demonstrate reliable decision making before authority expansion.
Define boundaries by domain, not by action -- Authority should scope to a coherent domain (e.g., "quality assessment") rather than individual actions (e.g., "run credo").
Make escalation paths explicit -- Every agent must know exactly which higher-tier agent receives its escalations.
Log everything, analyze periodically -- Decision audit trails should be reviewed for patterns of unnecessary escalation (authority too narrow) or poor decisions (authority too broad).

Confidence Threshold Calibration

Never lower thresholds to increase throughput -- If an agent frequently defers due to low confidence, improve the signal collection, not the threshold.
Use context-appropriate thresholds -- Critical decisions require 0.95; exploratory decisions can proceed at 0.60.
Monitor confidence calibration -- Track whether high-confidence decisions actually produce good outcomes.
Preserve contradictions -- Contradictory signals should reduce confidence, not be discarded.

Escalation Design

Escalation is not failure -- Recognizing the limits of one's authority is a feature, not a bug.
Provide full context on escalation -- The escalating agent must pass all collected signals, its confidence assessment, and its tentative recommendation.
Avoid escalation loops -- If an agent repeatedly escalates the same type of decision, the authority boundary needs adjustment.
Time-bound escalations -- Escalated decisions must have deadlines to prevent indefinite deferral.

Common Pitfalls

Authority Scope Creep

Agents gradually making decisions outside their defined scope. This occurs when success at lower-level decisions leads to implicit expansion of authority without formal review. Prevention: Strict boundary enforcement in the DecisionEngine, with authority violations logged and reported.

Confidence Inflation

Agents develop systematic overconfidence by counting correlated signals as independent. If three signals all derive from the same source, they provide the evidence of one signal, not three. Prevention: NABLA axiom 6 (Source Independence) explicitly weights independent sources higher.

Escalation Avoidance

Agents avoid escalation to appear more capable, making low-confidence decisions that should have been escalated. Prevention: Decision audit analysis that correlates decision confidence with outcome quality, flagging agents with high decision rates but low success rates.

Decision Paralysis

Agents defer too many decisions due to conservative thresholds, creating bottlenecks at higher tiers. Prevention: Monitor escalation rates per agent; if an agent escalates more than 40% of decisions, its authority boundary or signal collection needs adjustment.

Provenance Chain Breaks

Decisions made without traceable provenance -- the "trust me" anti-pattern. Prevention: NABLA axiom 7 (Provenance Mandatory) blocks any decision that cannot trace its reasoning chain back to original signals.

Single-Signal Decisions

Making autonomous decisions based on a single signal, violating the plurality requirement. Prevention: The ConfidenceScorer returns {:error, :insufficient_signals} when fewer than 2 signals are available, blocking the decision from proceeding.

Use Cases

Security Assessment Decisions

The Blue Team drift detection agents autonomously decide whether observed behavioral changes represent normal operation, benign drift, or potential security incidents. The blue-drift-detector evaluates signals from multiple sources (configuration changes, dependency updates, performance metrics) and autonomously classifies drift events without human intervention for routine cases.

Quality Gate Enforcement

The Quality Floor Guardian autonomously decides whether a commit should be blocked based on quality metrics. This decision considers current quality score, the nature of changes, regression risk, and historical patterns -- a genuine decision under uncertainty, not a simple threshold check.

Agent Orchestration

The supreme-coordinator autonomously decides which agents to activate for a given task, how to partition work, and when to declare a task complete. These orchestration decisions consider agent availability, specialization fit, current workload, and historical performance.

Evolution Advancement

The AutoEvolve system autonomously decides when the platform has accumulated sufficient improvements to warrant a generation advancement. This decision evaluates the composite fitness score, the nature and scope of improvements since the last generation, and the stability of the new state.

Incident Response

During autonomous operation, the Self-Healing system autonomously decides the appropriate response to detected anomalies: ignore (false positive), monitor (uncertain), remediate (known pattern), or escalate (unknown pattern). Each response level requires progressively higher confidence.

Automated Decision Making -- Rule-based counterpart that follows predetermined logic without reasoning under uncertainty
Authority Level -- Formal specification of what decisions an agent is authorized to make autonomously
Agent Tier -- Hierarchical tier system (L1-L5) that determines authority scope and escalation paths
NABLA Infinity -- Epistemic framework enforcing signal plurality, contradiction preservation, and provenance in decisions
Epistemic Pipeline -- Processing pipeline that transforms raw signals into actionable confidence assessments
Trinity Gate -- Three-condition verification gate required for critical autonomous decisions
Confidence Threshold -- Minimum confidence score required before a decision can proceed autonomously
Autonomous Agent -- Software entity that exercises autonomous decision making within its defined scope
No Mercy, No Doubts -- Doctrine governing the transition from exploration to decisive autonomous execution
Agent Registry -- Central registry tracking all agents and their authority boundaries
Quality Gate -- Automated verification gates that agents decide against during operations
Self-Healing -- Autonomous remediation system that makes incident response decisions

Connect & Contribute

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

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

Autonomous Decision Making

Definition

Overview

Technical Details

Authority Hierarchy

Decision Engine Architecture

Confidence Scoring Integration

Confidence Thresholds by Context

Decision Audit Trail

Implementation in Prismatic Platform

Agent Tier Decision Scope

NABLA Integration

Decision Flow Architecture

Comparison with Alternatives

Autonomous vs. Automated Decision Making

Comparison with Industry Approaches

Best Practices

Designing Authority Boundaries

Confidence Threshold Calibration

Escalation Design

Common Pitfalls

Authority Scope Creep

Confidence Inflation

Escalation Avoidance

Decision Paralysis

Provenance Chain Breaks

Single-Signal Decisions

Use Cases

Security Assessment Decisions

Quality Gate Enforcement

Agent Orchestration

Evolution Advancement

Incident Response

See Also

Connect & Contribute

Glossary

Related Terms

Autonomous Decision Making

Definition

Overview

Technical Details

Authority Hierarchy

Decision Engine Architecture

Confidence Scoring Integration

Confidence Thresholds by Context

Decision Audit Trail

Implementation in Prismatic Platform

Agent Tier Decision Scope

NABLA Integration

Decision Flow Architecture

Comparison with Alternatives

Autonomous vs. Automated Decision Making

Comparison with Industry Approaches

Best Practices

Designing Authority Boundaries

Confidence Threshold Calibration

Escalation Design

Common Pitfalls

Authority Scope Creep

Confidence Inflation

Escalation Avoidance

Decision Paralysis

Provenance Chain Breaks

Single-Signal Decisions

Use Cases

Security Assessment Decisions

Quality Gate Enforcement

Agent Orchestration

Evolution Advancement

Incident Response

Related Concepts

See Also

Connect & Contribute

Glossary

Related Terms