Definition and Overview

Strategic Advising is a structured methodology for providing expert guidance at the intersection of technology architecture, organizational capability, and business objectives. Unlike tactical consulting (which addresses immediate problems with immediate solutions), strategic advising operates at the system level -- analyzing how decisions made today will constrain or enable options available in the future, and recommending courses of action that optimize for long-term organizational resilience rather than short-term convenience.

The discipline draws from multiple fields: enterprise architecture frameworks (TOGAF, Zachman), decision theory, organizational design, and technology portfolio management. A strategic advisor does not simply answer the question "what technology should we use?" but rather addresses the deeper questions: "what capabilities do we need to build, what constraints do we operate under, and what architectural decisions will give us the most optionality as our understanding evolves?"

Within the Prismatic Platform, strategic advising is formalized as an agent capability. The Archer Supreme agent embodies the platform's strategic advising function, operating at the highest authority level to provide cross-domain analysis, milestone prioritization, and architectural direction. Strategic advising is not a passive activity -- in the NM/ND framework, once a strategic recommendation passes the Trinity Gate verification, it becomes a binding execution directive. Advice that survives rigorous epistemic validation is not optional guidance; it is the determined course of action.

The practical application spans multiple scales: from advising on individual architectural decisions (should this subsystem use GenServer or Agent?), through organizational decisions (how should the umbrella application be partitioned?), to strategic decisions (what market positioning maximizes platform value?). At each scale, the same principles apply: gather evidence from multiple independent sources, preserve contradictions rather than resolving them prematurely, verify conclusions through structural and logical analysis, and execute decisively once confidence thresholds are met.

Core Principles of Strategic Advising

Evidence-Based Decision Making

Strategic advising within the Prismatic Platform rejects opinion-driven decision making. Every recommendation must be traceable to evidence through the Provenance Mandatory axiom. This means that when an advisor recommends a particular architectural direction, the recommendation includes explicit references to the evidence that supports it, the reasoning chain from evidence to conclusion, and the confidence level assigned to the recommendation.

The Signal Plurality axiom further requires that no strategic recommendation rests on a single data source. A recommendation to adopt a particular technology must be supported by at minimum two independent signals -- perhaps performance benchmarks from the platform's own testing combined with adoption data from the broader ecosystem. Single-source recommendations are blocked by the epistemic framework regardless of how authoritative the single source appears.

Contradiction Preservation

One of the most counterintuitive aspects of strategic advising in the Prismatic framework is the requirement to preserve contradictory signals rather than resolving them. When evidence points in two directions simultaneously -- for example, when performance data favors one architecture while maintainability data favors another -- the advisor must present both directions with their supporting evidence rather than collapsing the contradiction into a single "balanced" recommendation.

This principle, drawn from the NABLA Infinity epistemic framework, produces better strategic outcomes because premature resolution of contradictions often means discarding the weaker signal. But "weaker" at the current moment does not mean "wrong." The weaker signal may represent an emerging trend that will dominate in six months. Preserving both signals allows the organization to monitor for changes that would shift the balance.

Optionality Over Optimization

Strategic advising in complex systems prioritizes architectural decisions that preserve future optionality over decisions that optimize for current requirements. This principle recognizes that requirements change, markets shift, and understanding deepens over time. An architecture that is 90% optimal for today's requirements but locks out future adaptation is worse than an architecture that is 80% optimal but maintains flexibility.

In practical terms, this means advising in favor of protocol-based designs over concrete implementations, umbrella applications over monoliths, and message-passing over shared state. Each of these choices trades marginal current performance for significant future adaptability.

Strategic Advising Framework

Phase 1: Landscape Assessment

The first phase of strategic advising maps the current state of the organization, technology, and competitive environment:

defmodule PrismaticAdvisor.LandscapeAssessment do
  @moduledoc """
  Structured landscape assessment for strategic advising sessions.
  Gathers evidence across technology, organization, and market dimensions.
  """

  @type dimension :: :technology | :organization | :market | :regulatory
  @type signal :: %{
    source: String.t(),
    dimension: dimension(),
    observation: String.t(),
    confidence: float(),
    timestamp: DateTime.t()
  }

  @spec assess(keyword()) :: {:ok, [signal()]} | {:error, term()}
  def assess(opts) do
    dimensions = Keyword.get(opts, :dimensions, [:technology, :organization, :market])

    signals =
      dimensions
      |> Enum.flat_map(&gather_signals/1)
      |> Enum.sort_by(& &1.confidence, :desc)
      |> enforce_plurality()

    {:ok, signals}
  end

  @spec gather_signals(dimension()) :: [signal()]
  defp gather_signals(:technology) do
    [
      assess_architecture_health(),
      assess_dependency_currency(),
      assess_performance_baselines(),
      assess_quality_metrics()
    ]
    |> List.flatten()
  end

  defp gather_signals(:organization) do
    [
      assess_team_capabilities(),
      assess_process_maturity(),
      assess_knowledge_distribution()
    ]
    |> List.flatten()
  end

  defp gather_signals(:market) do
    [
      assess_competitive_landscape(),
      assess_technology_trends(),
      assess_regulatory_environment()
    ]
    |> List.flatten()
  end

  defp gather_signals(:regulatory) do
    [
      assess_compliance_requirements(),
      assess_data_governance_posture()
    ]
    |> List.flatten()
  end

  @spec enforce_plurality([signal()]) :: [signal()]
  defp enforce_plurality(signals) do
    signals
    |> Enum.group_by(& &1.dimension)
    |> Enum.flat_map(fn {_dim, dim_signals} ->
      if length(dim_signals) >= 2, do: dim_signals, else: []
    end)
  end
end

Phase 2: Decision Mapping

The second phase identifies the key decisions that need to be made, their interdependencies, and their impact on future optionality:

Decision Category	Scope	Reversibility	Impact Horizon
Language/Runtime	Platform-wide	Effectively irreversible	5-10 years
Framework choice	Application-level	Difficult to reverse	3-5 years
Architecture pattern	Subsystem-level	Moderate effort to change	2-3 years
Library selection	Module-level	Relatively easy to swap	1-2 years
Configuration	Deployment-level	Easily reversible	Immediate

Strategic advising focuses effort proportionally to irreversibility. Easily reversible decisions should be made quickly and adjusted based on feedback. Effectively irreversible decisions (like choosing Elixir/OTP as the platform runtime) warrant the full weight of the advisory framework -- multiple signals, contradiction preservation, Trinity Gate validation, and formal verification where applicable.

Phase 3: Recommendation Synthesis

The synthesis phase combines landscape signals and decision mappings into actionable recommendations:

defmodule PrismaticAdvisor.RecommendationEngine do
  @moduledoc """
  Synthesizes strategic recommendations from landscape signals
  and decision mappings. All recommendations must pass confidence
  thresholds and Trinity Gate verification.
  """

  alias PrismaticAdvisor.LandscapeAssessment

  @type recommendation :: %{
    id: String.t(),
    title: String.t(),
    rationale: String.t(),
    supporting_signals: [LandscapeAssessment.signal()],
    contradicting_signals: [LandscapeAssessment.signal()],
    confidence: float(),
    optionality_impact: :preserves | :constrains | :neutral,
    reversibility: :high | :medium | :low,
    time_horizon: pos_integer()
  }

  @spec synthesize([LandscapeAssessment.signal()], keyword()) ::
          {:ok, [recommendation()]} | {:error, term()}
  def synthesize(signals, opts \\ []) do
    threshold = Keyword.get(opts, :confidence_threshold, 0.80)

    recommendations =
      signals
      |> cluster_by_theme()
      |> Enum.map(&build_recommendation/1)
      |> Enum.filter(&(&1.confidence >= threshold))
      |> rank_by_impact()

    {:ok, recommendations}
  end

  @spec build_recommendation({String.t(), [LandscapeAssessment.signal()]}) ::
          recommendation()
  defp build_recommendation({theme, theme_signals}) do
    {supporting, contradicting} = partition_signals(theme_signals)

    %{
      id: generate_id(theme),
      title: theme,
      rationale: synthesize_rationale(supporting, contradicting),
      supporting_signals: supporting,
      contradicting_signals: contradicting,
      confidence: compute_confidence(supporting, contradicting),
      optionality_impact: assess_optionality(theme),
      reversibility: assess_reversibility(theme),
      time_horizon: estimate_horizon(theme)
    }
  end
end

Phase 4: Validation and Commitment

Recommendations that meet the confidence threshold proceed to Trinity Gate validation. For strategic decisions with long-term impact (reversibility: :low), all three gates are mandatory. For tactical recommendations (reversibility: :high), structural and logical gates suffice.

Once validated, the NM/ND doctrine takes effect. Validated strategic advice becomes a binding commitment -- the "No Mercy" principle demands complete execution without hedging, and the "No Doubts" principle means the validation process has already resolved uncertainty. Teams do not re-litigate validated strategic decisions during implementation.

Architecture and Implementation

Advisory Agent Hierarchy

The Prismatic Platform implements strategic advising through a tiered agent hierarchy:

Archer Supreme (L1 - Strategic)
    |
    +-- Supreme Coordinator (L2 - Operational)
    |       +-- Domain advisors (technology, security, compliance)
    |       +-- Cross-domain synthesizers
    |
    +-- Strategic Command (L2 - Operational)
    |       +-- Milestone planning
    |       +-- Resource allocation
    |       +-- Priority arbitration
    |
    +-- Tactical Execution (L3 - Tactical)
            +-- Implementation guidance
            +-- Progress monitoring
            +-- Feedback collection

Each level has distinct advisory responsibilities. The Archer Supreme agent handles platform-wide strategic direction. The Supreme Commander coordinates across domains. Strategic Command translates strategy into milestones and resource plans. Tactical Execution provides implementation-level guidance.

Advisory Session GenServer

Strategic advising sessions are managed as stateful processes within the platform's supervision tree:

defmodule PrismaticAdvisor.Session do
  @moduledoc """
  Manages the lifecycle of a strategic advising session.
  Tracks signals gathered, recommendations made, and decisions taken.
  """

  use GenServer

  @type state :: %{
    session_id: String.t(),
    started_at: DateTime.t(),
    signals: [map()],
    recommendations: [map()],
    decisions: [map()],
    status: :gathering | :synthesizing | :validating | :committed
  }

  def start_link(opts) do
    session_id = Keyword.fetch!(opts, :session_id)
    GenServer.start_link(__MODULE__, opts, name: via_registry(session_id))
  end

  @impl true
  def init(opts) do
    state = %{
      session_id: Keyword.fetch!(opts, :session_id),
      started_at: DateTime.utc_now(),
      signals: [],
      recommendations: [],
      decisions: [],
      status: :gathering
    }

    {:ok, state}
  end

  @impl true
  def handle_call({:add_signal, signal}, _from, %{status: :gathering} = state) do
    updated = %{state | signals: [signal | state.signals]}
    {:reply, {:ok, length(updated.signals)}, updated}
  end

  @impl true
  def handle_call(:synthesize, _from, %{status: :gathering} = state) do
    case PrismaticAdvisor.RecommendationEngine.synthesize(state.signals) do
      {:ok, recommendations} ->
        updated = %{state | recommendations: recommendations, status: :synthesizing}
        {:reply, {:ok, recommendations}, updated}

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

  @impl true
  def handle_call({:commit_decision, decision_id}, _from, %{status: :validating} = state) do
    case find_recommendation(state.recommendations, decision_id) do
      {:ok, recommendation} ->
        decision = %{recommendation: recommendation, committed_at: DateTime.utc_now()}
        updated = %{state | decisions: [decision | state.decisions], status: :committed}
        {:reply, {:ok, decision}, updated}

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

  defp via_registry(session_id) do
    {:via, Registry, {PrismaticAdvisor.Registry, session_id}}
  end

  defp find_recommendation(recommendations, id) do
    case Enum.find(recommendations, &(&1.id == id)) do
      nil -> :error
      rec -> {:ok, rec}
    end
  end
end

Telemetry Integration

Advisory sessions emit telemetry events for monitoring and analysis:

defmodule PrismaticAdvisor.Telemetry do
  @moduledoc """
  Telemetry events for strategic advising sessions.
  Tracks session lifecycle, signal gathering, and decision quality.
  """

  @spec emit_session_event(atom(), map()) :: :ok
  def emit_session_event(event, metadata) do
    :telemetry.execute(
      [:prismatic_advisor, :session, event],
      %{timestamp: System.monotonic_time()},
      metadata
    )
  end

  @spec emit_recommendation_event(atom(), map()) :: :ok
  def emit_recommendation_event(event, metadata) do
    :telemetry.execute(
      [:prismatic_advisor, :recommendation, event],
      %{
        confidence: metadata.confidence,
        signal_count: length(metadata.signals)
      },
      metadata
    )
  end
end

Usage in Prismatic Platform

Platform Architecture Advising

The Prismatic Platform uses strategic advising for its own architectural evolution. When Generation 19 introduced the Ecosystem Expansion phase with 4 OSS packages, the decision went through the full advisory framework:

Landscape assessment: Gathered signals from community demand, competitive analysis, and internal capability evaluation
Decision mapping: Evaluated open-source packaging options (SDK, Plugin Kit, Security, UI) with reversibility analysis
Synthesis: Recommended dual-track positioning (platform + ecosystem) with confidence 0.92
Validation: Passed Trinity Gate at all three levels
Execution: NM/ND commitment to full ecosystem expansion

Technology Due Diligence

Strategic advising extends to technology due diligence for the platform's competitive intelligence capabilities (Prismatic Perimeter):

# Evaluate a technology choice for the Perimeter scanning subsystem
{:ok, session} = PrismaticAdvisor.Session.start_link(session_id: "perimeter-scanner-eval")

# Gather signals from multiple dimensions
:ok = PrismaticAdvisor.Session.add_signal(session, %{
  source: "benchmark_suite",
  dimension: :technology,
  observation: "Concurrent HTTP scanning achieves 10k req/s on BEAM",
  confidence: 0.95,
  timestamp: DateTime.utc_now()
})

:ok = PrismaticAdvisor.Session.add_signal(session, %{
  source: "ecosystem_analysis",
  dimension: :market,
  observation: "Elixir OSINT tooling growing 40% YoY in adoption",
  confidence: 0.78,
  timestamp: DateTime.utc_now()
})

# Synthesize recommendations
{:ok, recommendations} = PrismaticAdvisor.Session.synthesize(session)

Milestone Prioritization

The Archer Supreme agent uses strategic advising to prioritize platform milestones. The 20 GitLab milestones are continuously evaluated against current signals, and priority adjustments are recommended when the landscape shifts. The advisory framework ensures that priority changes are evidence-based rather than reactive to the most recent complaint or the loudest voice.

Advisory Anti-Patterns

Strategic advising in complex systems faces several recurring failure modes:

Anti-Pattern	Description	Mitigation
HiPPO	Highest Paid Person's Opinion overrides evidence	Signal Plurality axiom enforcement
Analysis Paralysis	Perpetual gathering without commitment	Confidence threshold triggers transition
Recency Bias	Over-weighting the most recent signal	Time Decay axiom with weighted timestamps
Sunk Cost Anchoring	Defending past decisions against new evidence	Contradiction Preservation forces acknowledgment
Scope Creep	Advisory scope expanding without bounds	Session lifecycle management with explicit phases
Confirmation Bias	Seeking signals that confirm existing beliefs	Source Independence axiom weighting

Best Practices

Separate advisory from execution roles. The same agent or team should not both advise and implement. Advisory independence requires freedom from implementation pressure. In the Prismatic hierarchy, the Archer Supreme advises but does not directly implement.
Document the reasoning chain, not just the recommendation. A recommendation without its supporting evidence and reasoning chain is an opinion. Future decision-makers need the reasoning to evaluate whether the original conditions still hold.
Set explicit confidence thresholds before gathering evidence. Deciding how much evidence is "enough" after seeing the evidence introduces bias. Establish thresholds upfront based on the reversibility and impact of the decision.
Time-box advisory phases. Strategic advising that continues indefinitely produces diminishing returns. The four-phase framework (assessment, mapping, synthesis, validation) provides natural checkpoints and time boundaries.
Re-evaluate when conditions change. Strategic advice is timestamped, not eternal. The Time Decay axiom applies to recommendations as well as evidence. Recommendations older than their time horizon should be re-evaluated rather than blindly followed.
Preserve minority signals. The most valuable strategic insight often comes from the minority signal that contradicts the prevailing view. Discarding minority signals to achieve consensus destroys the information that would have prevented strategic surprises.

Common Pitfalls

Treating all decisions as strategic: Not every technical decision warrants the full advisory framework. Configuration choices, library version bumps, and formatting decisions should be made quickly without strategic overhead. Reserve the full framework for decisions with low reversibility and long time horizons.
Confusing confidence with certainty: A confidence score of 0.95 means the conclusion is well-supported, not that it is guaranteed. Strategic advisors must communicate the distinction clearly to avoid creating false certainty in stakeholders.
Advising without understanding the implementation context: Abstract strategic advice that ignores implementation constraints produces elegant plans that cannot be executed. Advisory sessions must include implementation-level signals alongside strategic ones.
Ignoring organizational dynamics: Technology strategy that assumes a frictionless organization will fail. Team capabilities, knowledge distribution, and organizational culture are first-class inputs to strategic advising, not afterthoughts.

Archer Supreme -- Platform's highest-level strategic advisory agent
Strategic Supreme -- Supreme-level strategic decision-making authority
Strategic Command -- Operational translation of strategic direction into milestone plans
Supreme Commander -- Cross-domain coordination agent supporting advisory function
Authority Level -- Hierarchical authority governing advisory scope and binding power
Trinity Gate -- Verification mechanism validating strategic recommendations
Confidence Threshold -- Score thresholds that determine recommendation readiness
NABLA Infinity -- Epistemic framework underlying evidence-based advisory methodology
Quality Gate -- Automated verification gates complementing advisory process
Agent Orchestration -- Multi-agent coordination enabling cross-domain advisory analysis

Connect & Contribute

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

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

Strategic Advising