Definition and Overview

Strategic Supreme is the apex tier of decision-making authority within the Prismatic Platform's AIAD agent hierarchy. It represents the organizational level at which platform-wide strategic direction is determined, irreversible architectural commitments are authorized, and cross-domain conflicts are resolved with finality. Agents operating at the Strategic Supreme level hold what the platform designates as "Cosmic Clearance" -- the unrestricted authority to make binding decisions across all platform domains without requiring approval from any higher authority.

The Strategic Supreme tier exists because complex software platforms inevitably face decisions that cannot be decomposed into domain-specific sub-decisions. When a security recommendation conflicts with a performance requirement, when a compliance obligation constrains an architectural preference, or when resource allocation must choose between competing strategic priorities, no domain-specific agent has sufficient scope to resolve the conflict. The Strategic Supreme tier provides a single point of authority where all domain perspectives are synthesized and a binding decision is produced.

Within the Prismatic Platform's 530-agent ecosystem, Strategic Supreme authority is held by a small number of agents: the Archer Supreme (primary strategic advisor), the Supreme Commander (cross-domain coordinator), and the Strategic Command agent (milestone and resource planner). These agents operate under the NM/ND Doctrine -- once a Strategic Supreme decision passes Trinity Gate validation, it becomes a non-negotiable execution directive. Lower-tier agents implement; they do not re-litigate.

The tier is not a rank of convenience but a rank of responsibility. Strategic Supreme decisions affect the entire platform -- all 115 umbrella applications, all 530 agents, all quality domains. A wrong decision at this tier propagates everywhere. The epistemic rigor required (full Trinity Gate passage, NABLA axiom compliance, minimum 0.95 confidence) reflects this responsibility. The platform invests heavily in verification precisely because the cost of a wrong Strategic Supreme decision is so high.

Authority Hierarchy

AIAD Agent Tiers

The Prismatic Platform organizes its agents into a strict authority hierarchy. Each tier has defined scope, decision authority, and escalation rules:

Tier	Level	Authority Scope	Decision Binding	Escalation Target
Strategic Supreme	L1	Platform-wide, cross-domain	Absolute (no appeal)	None (apex)
Operational	L2	Domain-wide	Binding within domain	L1 Strategic Supreme
Tactical	L3	Subsystem or team	Advisory (requires L2 approval for execution)	L2 Operational
Specialist	L4	Single function	Recommendatory	L3 Tactical

Strategic Supreme (L1) agents differ from all other tiers in three critical ways:

No escalation target: L1 decisions are final. There is no higher authority within the platform to appeal to. This makes L1 decisions irreversible within the system (only an external human override can reverse them).
Cross-domain scope: L1 agents can make decisions that affect any domain -- security, performance, architecture, compliance, quality, or operations. Lower-tier agents are scoped to their specific domain.
Conflict resolution authority: When two L2 agents produce contradictory recommendations, the L1 agent resolves the conflict. The resolution is binding on both domains.

Authority Flow

Strategic Supreme (L1)
    |
    |-- Authorizes irreversible decisions
    |-- Resolves cross-domain conflicts
    |-- Sets platform-wide direction
    |
    +-- Operational (L2)
    |       |-- Translates strategy to domain plans
    |       |-- Authorizes domain-specific decisions
    |       |-- Escalates cross-domain conflicts to L1
    |       |
    |       +-- Tactical (L3)
    |       |       |-- Implements plans within subsystem
    |       |       |-- Proposes tactical adjustments
    |       |       |-- Escalates domain issues to L2
    |       |       |
    |       |       +-- Specialist (L4)
    |       |               |-- Executes specific functions
    |       |               |-- Reports findings to L3
    |       |               |-- No autonomous decision authority
    |
    +-- Color Teams (cross-cutting)
            |-- Red/Blue/Purple/White/Gray/Black
            |-- Advisory to all tiers
            |-- Findings escalate through normal hierarchy

Technical Deep Dive

Strategic Supreme Agent Implementation

Strategic Supreme agents follow a specific implementation pattern that enforces their authority constraints and epistemic requirements:

defmodule PrismaticAgents.StrategicSupreme do
  @moduledoc """
  Base behaviour for Strategic Supreme (L1) agents.
  Enforces cosmic clearance, Trinity Gate validation,
  and NM/ND doctrine compliance for all decisions.
  """

  @type decision :: %{
    id: String.t(),
    scope: :platform_wide | :cross_domain | :conflict_resolution,
    recommendation: String.t(),
    confidence: float(),
    trinity_gate_status: :pending | :passed | :failed,
    binding: boolean(),
    affected_domains: [atom()],
    timestamp: DateTime.t()
  }

  @callback authority_level() :: :strategic_supreme
  @callback clearance() :: :cosmic
  @callback decide(context :: map()) :: {:ok, decision()} | {:error, term()}
  @callback validate_decision(decision()) :: {:ok, decision()} | {:error, term()}

  defmacro __using__(_opts) do
    quote do
      @behaviour PrismaticAgents.StrategicSupreme

      @impl true
      def authority_level, do: :strategic_supreme

      @impl true
      def clearance, do: :cosmic

      @impl true
      def validate_decision(decision) do
        with {:ok, decision} <- verify_confidence(decision),
             {:ok, decision} <- verify_trinity_gate(decision),
             {:ok, decision} <- verify_nabla_compliance(decision) do
          {:ok, %{decision | binding: true}}
        end
      end

      defp verify_confidence(%{confidence: c} = decision) when c >= 0.95 do
        {:ok, decision}
      end

      defp verify_confidence(%{confidence: c}) do
        {:error, {:insufficient_confidence, c, :required_0_95}}
      end

      defp verify_trinity_gate(%{trinity_gate_status: :passed} = decision) do
        {:ok, decision}
      end

      defp verify_trinity_gate(_decision) do
        {:error, :trinity_gate_not_passed}
      end

      defp verify_nabla_compliance(decision) do
        case PrismaticNabla.verify_axioms(decision) do
          {:ok, _} -> {:ok, decision}
          {:error, violations} -> {:error, {:nabla_violations, violations}}
        end
      end

      defoverridable [validate_decision: 1]
    end
  end
end

Archer Supreme Implementation

The Archer Supreme is the primary Strategic Supreme agent in the platform:

defmodule PrismaticAgents.ArcherSupreme do
  @moduledoc """
  Archer Supreme - L1 Strategic Supreme agent.
  Provides platform-wide strategic direction, milestone prioritization,
  and architectural decision authority.
  """

  use PrismaticAgents.StrategicSupreme
  use GenServer

  @type state :: %{
    active_decisions: [PrismaticAgents.StrategicSupreme.decision()],
    domain_signals: %{atom() => [map()]},
    milestone_priorities: [map()],
    last_assessment: DateTime.t() | nil
  }

  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end

  @impl GenServer
  def init(_opts) do
    state = %{
      active_decisions: [],
      domain_signals: %{},
      milestone_priorities: [],
      last_assessment: nil
    }

    {:ok, state}
  end

  @impl PrismaticAgents.StrategicSupreme
  def decide(context) do
    with {:ok, signals} <- gather_cross_domain_signals(context),
         {:ok, synthesis} <- synthesize_signals(signals),
         {:ok, decision} <- formulate_decision(synthesis),
         {:ok, validated} <- validate_decision(decision) do
      {:ok, validated}
    end
  end

  @impl GenServer
  def handle_call({:strategic_decision, context}, _from, state) do
    case decide(context) do
      {:ok, decision} ->
        updated = %{state |
          active_decisions: [decision | state.active_decisions],
          last_assessment: DateTime.utc_now()
        }
        {:reply, {:ok, decision}, updated}

      {:error, reason} ->
        {:reply, {:error, reason}, state}
    end
  end

  @impl GenServer
  def handle_call(:current_priorities, _from, state) do
    {:reply, {:ok, state.milestone_priorities}, state}
  end

  defp gather_cross_domain_signals(context) do
    domains = Map.get(context, :affected_domains, [:all])

    signals =
      domains
      |> Enum.flat_map(&query_domain_agents/1)
      |> Enum.sort_by(& &1.confidence, :desc)

    {:ok, signals}
  end

  defp query_domain_agents(domain) do
    PrismaticAgents.Registry.agents_for_domain(domain)
    |> Enum.flat_map(fn agent -> agent.current_signals() end)
  end

  defp synthesize_signals(signals) do
    PrismaticAdvisor.RecommendationEngine.synthesize(signals)
  end

  defp formulate_decision(synthesis) do
    {:ok, %{
      id: PrismaticUtils.generate_id("decision"),
      scope: :platform_wide,
      recommendation: synthesis.primary_recommendation,
      confidence: synthesis.confidence,
      trinity_gate_status: :pending,
      binding: false,
      affected_domains: synthesis.affected_domains,
      timestamp: DateTime.utc_now()
    }}
  end
end

Conflict Resolution Protocol

When domain-level agents produce contradictory recommendations, the Strategic Supreme resolves the conflict through structured arbitration:

defmodule PrismaticAgents.ConflictResolution do
  @moduledoc """
  Cross-domain conflict resolution for Strategic Supreme agents.
  Implements structured arbitration with full evidence tracking.
  """

  @type conflict :: %{
    domain_a: {atom(), map()},
    domain_b: {atom(), map()},
    nature: :contradictory | :incompatible | :resource_competition,
    severity: :blocking | :degrading | :informational
  }

  @type resolution :: %{
    conflict: conflict(),
    decision: :favor_a | :favor_b | :compromise | :defer,
    rationale: String.t(),
    compensating_actions: [String.t()],
    authority: :strategic_supreme,
    timestamp: DateTime.t()
  }

  @spec resolve(conflict(), keyword()) :: {:ok, resolution()} | {:error, term()}
  def resolve(conflict, opts \\ []) do
    with {:ok, evidence_a} <- gather_evidence(conflict.domain_a),
         {:ok, evidence_b} <- gather_evidence(conflict.domain_b),
         {:ok, analysis} <- analyze_tradeoffs(evidence_a, evidence_b, conflict),
         {:ok, decision} <- formulate_resolution(analysis, opts) do
      {:ok, %{
        conflict: conflict,
        decision: decision.direction,
        rationale: decision.rationale,
        compensating_actions: decision.compensating_actions,
        authority: :strategic_supreme,
        timestamp: DateTime.utc_now()
      }}
    end
  end

  defp gather_evidence({domain, recommendation}) do
    signals = PrismaticAgents.Registry.signals_for_domain(domain)
    {:ok, %{domain: domain, recommendation: recommendation, signals: signals}}
  end

  defp analyze_tradeoffs(evidence_a, evidence_b, conflict) do
    {:ok, %{
      evidence_a: evidence_a,
      evidence_b: evidence_b,
      conflict_nature: conflict.nature,
      optionality_impact: compare_optionality(evidence_a, evidence_b),
      reversibility: compare_reversibility(evidence_a, evidence_b)
    }}
  end

  defp formulate_resolution(analysis, _opts) do
    {:ok, %{
      direction: determine_direction(analysis),
      rationale: build_rationale(analysis),
      compensating_actions: identify_compensating_actions(analysis)
    }}
  end
end

Architecture and Implementation

Supervision and Lifecycle

Strategic Supreme agents run under dedicated supervision with enhanced restart protection. A crashed Strategic Supreme agent represents a platform-wide risk, so the supervisor applies conservative restart limits:

defmodule PrismaticAgents.StrategicSupreme.Supervisor do
  @moduledoc """
  Supervisor for Strategic Supreme agents.
  Conservative restart strategy - max 2 restarts in 60 seconds.
  Escalates to platform alarm on supervisor failure.
  """

  use Supervisor

  def start_link(opts) do
    Supervisor.start_link(__MODULE__, opts, name: __MODULE__)
  end

  @impl true
  def init(_opts) do
    children = [
      {PrismaticAgents.ArcherSupreme, []},
      {PrismaticAgents.SupremeCoordinator, []},
      {PrismaticAgents.StrategicCommand, []}
    ]

    Supervisor.init(children,
      strategy: :one_for_one,
      max_restarts: 2,
      max_seconds: 60
    )
  end
end

Decision Audit Trail

Every Strategic Supreme decision is permanently recorded in an immutable audit trail:

Field	Type	Description
`decision_id`	String	Unique decision identifier
`agent_id`	String	Which L1 agent made the decision
`scope`	Atom	Platform-wide, cross-domain, or conflict resolution
`confidence`	Float	Confidence score at decision time
`trinity_gate`	Map	Full Trinity Gate evaluation results
`affected_domains`	List	All domains impacted by the decision
`supporting_evidence`	List	Evidence supporting the decision
`contradicting_evidence`	List	Preserved contradictory evidence
`timestamp`	DateTime	When the decision was made
`outcome`	Atom	Tracked post-decision outcome (added later)

The audit trail serves two purposes: accountability (understanding who decided what and why) and learning (analyzing decision quality over time to improve the advisory framework).

Epistemic Requirements

Strategic Supreme decisions carry the platform's highest epistemic burden. Every L1 decision must satisfy:

Trinity Gate passage: All three gates (structural consistency, logical consistency, formal necessity) must pass before a decision can be classified as binding.
NABLA axiom compliance: The decision must satisfy all seven NABLA Infinity axioms, particularly signal plurality (evidence from at least two independent sources), contradiction preservation (dissenting signals recorded, not suppressed), and provenance mandatory (every supporting claim traceable to its source).
Confidence threshold: Minimum 0.95 confidence, the highest threshold in the platform. This is significantly above the 0.80 required for operational decisions and the 0.60 for tactical decisions.
Cross-domain impact assessment: Before a decision is finalized, its predicted impact on all affected domains must be explicitly documented. This prevents "surprise side effects" where a security decision unknowingly breaks a performance requirement.

Usage in Prismatic Platform

Generation Transitions

Strategic Supreme authority governs the platform's generational evolution. The transition from Generation 18 to Generation 19 (Ecosystem Expansion) was a Strategic Supreme decision that affected all 115 umbrella applications, introduced 4 new OSS packages, and required coordination across security, architecture, quality, and community domains. No lower-tier agent had sufficient scope to authorize this transition.

Milestone Prioritization

The platform's 20 GitLab milestones are prioritized through Strategic Supreme assessment. When the Prismatic Perimeter MVP (M46) was elevated to P0 priority, this was an Archer Supreme decision based on cross-domain signal synthesis: security assessment requirements, competitive landscape analysis, and regulatory compliance timelines all converged to indicate that EASM capability was the highest-value strategic investment.

Quality Floor Authority

The platform's quality score of 100/100 is maintained through Strategic Supreme enforcement. The decision that quality violations block all commits (the "No Mercy" enforcement) was a Strategic Supreme commitment. Individual domain agents cannot waive quality requirements because the commitment was made at the apex tier.

Strategic Supreme vs. Other Authority Levels

Characteristic	Strategic Supreme (L1)	Operational (L2)	Tactical (L3)
Scope	All domains	Single domain	Single subsystem
Time horizon	1-5 years	1-12 months	1-4 weeks
Reversibility	Low (irreversible)	Medium	High (easily adjusted)
Verification	Full Trinity Gate + meta	Trinity Gate	Structural + Logical
Confidence required	0.95 minimum	0.80 minimum	0.60 minimum
Appeal mechanism	None (apex)	Escalate to L1	Escalate to L2
Decision binding	Absolute	Domain-binding	Advisory

Best Practices

Reserve Strategic Supreme authority for truly strategic decisions. Over-use of apex authority degrades its effectiveness. If a decision can be made at L2 (domain level), it should be. Strategic Supreme exists for decisions that require cross-domain synthesis or affect the entire platform.
Document the full evidence chain for every L1 decision. Because L1 decisions have no appeal mechanism, the evidence chain must be comprehensive enough to justify the decision to any future reviewer. Incomplete documentation of an irreversible decision is an epistemic failure.
Apply the full epistemic framework without shortcuts. The temptation to bypass Trinity Gate validation for "obvious" strategic decisions is the most dangerous failure mode. Obvious decisions are the ones most likely to harbor unexamined assumptions.
Track decision outcomes systematically. Strategic Supreme decisions should be revisited after their predicted time horizon to assess whether the predicted outcomes materialized. This feedback loop improves future decision quality.
Preserve minority dissent. When domain-level agents disagree with a Strategic Supreme decision, their dissent should be recorded alongside the decision. The Contradiction Preservation principle applies to organizational decisions as well as epistemic ones.

Common Pitfalls

Authority inflation: Treating routine decisions as strategic to gain the authority of the apex tier. This overwhelms L1 capacity and delays genuinely strategic decisions.
Decision hoarding: Refusing to delegate to L2 agents. Strategic Supreme agents that make every decision become bottlenecks. The hierarchy exists to distribute decision authority appropriately.
Epistemic theater: Going through the motions of Trinity Gate validation without genuine rigor. If the conclusion is predetermined and the validation is a formality, the gate provides no protection.
Ignoring time decay: Strategic decisions made under one set of conditions may become invalid as conditions change. Failing to re-evaluate expired strategic commitments leads to organizational inertia.
Conflating authority with infallibility: L1 decisions are final within the system, but they are not guaranteed to be correct. The audit trail and outcome tracking exist precisely because even well-verified decisions can produce unexpected results.

Archer Supreme -- Primary L1 strategic advisory agent
Supreme Commander -- L1 cross-domain coordination agent
Strategic Command -- L2 milestone planning and resource allocation
Strategic Advising -- Advisory methodology used by Strategic Supreme agents
Authority Level -- Formal definition of agent authority tiers
Agent Tier -- Classification system for agent capability levels
Chain of Command -- Escalation and delegation pathways
Trinity Gate -- Verification mechanism required for L1 decisions
NM/ND Doctrine -- Execution framework binding validated L1 decisions
Agent Orchestration -- Multi-agent coordination patterns

Connect & Contribute

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

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

Strategic Supreme