Red Team

Overview

The Red Team constitutes the adversarial simulation arm of the Prismatic Platform's six-team color-team security architecture. Through controlled simulation of epistemic attacks using five defined attack primitives, Red Team identifies vulnerabilities in the platform's knowledge systems, belief formation processes, and decision-making pipelines before real adversaries can exploit them. All operations are conducted within sandboxed environments using exclusively synthetic data, ensuring that adversarial capability development serves strictly defensive purposes.

The theoretical foundation of Red Team operations draws from adversarial machine learning, epistemic game theory, and red team/blue team methodologies established in military and cybersecurity domains. The Prismatic Platform extends these traditional approaches by focusing specifically on epistemic attacks — attacks that target the truthfulness, confidence, and reliability of the platform's knowledge rather than its infrastructure. This focus reflects the platform's recognition that for an intelligence and due diligence platform, the integrity of information is the primary attack surface.

Red Team maintains a comprehensive 329-entry attack scenario taxonomy organized across six categories: information manipulation, confidence attacks, source spoofing, gradual drift, attention manipulation, and multi-vector composite attacks. Each scenario is documented with formal attack trees, expected impact models, and detection signatures that feed directly into Blue Team defensive development and Purple Team synthesis operations.

Mission and Doctrine

The Red Team mission is to systematically identify epistemic vulnerabilities through controlled adversarial simulation, providing the platform with a continuously updated understanding of its attack surface. This mission operates under strict safety constraints that prevent any transition from simulation to actual capability.

Mission Principles

The NO MERCY, NO DOUBTS doctrine governs Red Team operations with particular emphasis: NO MERCY demands that simulations are thorough and uncompromising in finding vulnerabilities — no attack surface is left unexplored due to convenience or comfort. NO DOUBTS requires that every vulnerability finding is evidence-based, reproducible, and documented with complete provenance.

Team Composition

The Red Team comprises four specialized agents operating in a hierarchical command structure with clear separation of responsibilities.

red-commander

The Red Commander operates at L3 strategic authority, orchestrating multi-phase adversarial campaigns that combine multiple attack primitives into realistic threat scenarios. The commander maintains the 329-entry scenario taxonomy, tracks vulnerability discovery rates across campaigns, and ensures that simulation priorities align with the platform's evolving threat landscape. Communication flows from Red Commander to Purple Team for synthesis and to Blue Team for defense development.

red-epistemic-attacker

The Epistemic Attacker specializes in the two most direct attack primitives: truth distortion (injecting false information into the platform's knowledge base) and signal poisoning (corrupting input data streams). This agent designs and executes simulations that test the platform's ability to detect and reject manipulated information, with particular focus on attacks that attempt to bypass the NABLA Infinity signal plurality requirements.

red-drift-inducer

The Drift Inducer specializes in the most subtle and dangerous attack category: gradual, sub-threshold drift that shifts the platform's beliefs over time without triggering detection thresholds. This agent models how small, individually insignificant perturbations can accumulate into significant epistemic compromise, testing the platform's baseline comparison and drift detection capabilities maintained by Blue Team.

red-scenario-generator

The Scenario Generator composes multi-technique attack scenarios from the 329-entry taxonomy, creating realistic adversarial campaigns that combine multiple primitives in sequence or parallel. This agent also maintains salience hijacking capabilities — testing whether the platform can be tricked into focusing on decoy signals while actual attacks proceed undetected.

Attack Primitives

Red Team operations are organized around five formally defined epistemic attack primitives, each targeting a different aspect of the platform's knowledge integrity.

The Five Primitives

Simulation Framework

defmodule PrismaticDark.RedTeam.SimulationEngine do
  @moduledoc """
  Sandboxed adversarial simulation engine for Red Team operations.
  All simulations use synthetic data only within isolated environments.
  """

  @type primitive :: :truth_distortion | :confidence_manipulation |
                     :signal_poisoning | :drift_induction | :salience_hijacking

  @type scenario :: %{
    id: String.t(),
    primitives: [primitive()],
    target_domain: atom(),
    synthetic_data: map(),
    success_criteria: map(),
    safety_bounds: map()
  }

  @spec execute_scenario(scenario()) :: {:ok, map()} | {:error, :safety_violation}
  def execute_scenario(%{} = scenario) do
    with :ok <- verify_sandbox_isolation(),
         :ok <- verify_synthetic_data(scenario.synthetic_data),
         :ok <- initialize_monitoring(scenario),
         {:ok, result} <- run_simulation(scenario),
         :ok <- validate_safety_bounds(result, scenario.safety_bounds) do
      report = generate_vulnerability_report(scenario, result)

      :telemetry.execute(
        [:prismatic, :red_team, :simulation, :complete],
        %{duration: result.duration_ms, vulnerabilities_found: length(report.findings)},
        %{scenario_id: scenario.id, primitives: scenario.primitives}
      )

      {:ok, report}
    end
  end

  defp verify_sandbox_isolation do
    case PrismaticDark.Sandbox.status() do
      :isolated -> :ok
      status -> {:error, {:sandbox_not_isolated, status}}
    end
  end

  defp verify_synthetic_data(data) do
    if PrismaticDark.DataClassifier.synthetic?(data),
      do: :ok,
      else: {:error, :non_synthetic_data_detected}
  end
end

Scenario Taxonomy

Red Team maintains a comprehensive 329-entry attack scenario taxonomy that catalogs known epistemic attack patterns. This taxonomy serves as both an operational playbook and a knowledge base for adversarial research.

Scenario Lifecycle

flowchart TD
    Tax["Taxonomy Entry"]
    Sel["Campaign Selection"]
    Param["Scenario Parameterization"]
    Sand["Sandbox Initialization"]
    Sim["Simulation Execution"]
    Impact["Impact Analysis"]
    Report["Vulnerability Report"]
    Hand["Purple / Blue Team Handoff"]
    Review["Periodic Review"]
    Update["Taxonomy Update"]

    Tax --> Sel --> Param --> Sand --> Sim --> Impact --> Report --> Hand
    Sim --> Update
    Update --> Review --> Tax

    classDef taxonomy fill:#1e293b,stroke:#3b82f6,color:#fff
    classDef sim fill:#0f172a,stroke:#dc2626,color:#fff
    classDef hand fill:#1e293b,stroke:#a855f7,color:#fff
    class Tax,Review,Update taxonomy
    class Sand,Sim,Impact sim
    class Report,Hand hand

Safety Protocols

Red Team safety protocols ensure that adversarial simulation capability never transitions into actual attack capability.

Sandbox Isolation

Ethics Enforcement

Automated ethics checks execute every 10-15 seconds during active simulations:

1. Scope boundary verification — confirms simulation remains within approved parameters
2. Data classification check — verifies all data in play is classified as synthetic
3. Impact assessment — monitors simulation impact against safety bounds
4. Escalation trigger evaluation — checks if simulation results warrant immediate Blue Team notification

Forbidden Activities

Technical Architecture

Red Team operations are built on the PrismaticDark OTP application, which provides sandboxed execution environments for all adversarial simulation activities.

System Architecture

flowchart TD
    Cmd["Red Commander (L3)"]
    Cmd --> Plan["Campaign Planner"]
    Cmd --> Sim["Simulation Engine"]
    Cmd --> Rep["Reporting Pipeline"]

    Plan --> P1["Scenario Selector<br/>(329-entry taxonomy)"]
    Plan --> P2["Parameter Generator<br/>(synthetic data)"]
    Plan --> P3["Resource Allocator"]

    Sim --> S1["Sandbox Manager"]
    Sim --> S2["Primitive Executors<br/>(5 types)"]
    Sim --> S3["Impact Analyzer"]
    Sim --> S4["Safety Monitor<br/>(10-15s ethics checks)"]

    Rep --> R1["Vulnerability Reporter"]
    Rep --> R2["Purple Team Emitter"]
    Rep --> R3["Audit Logger"]

    classDef tier fill:#1e293b,stroke:#dc2626,color:#fff
    classDef leaf fill:#0f172a,stroke:#64748b,color:#e2e8f0
    class Cmd,Plan,Sim,Rep tier
    class P1,P2,P3,S1,S2,S3,S4,R1,R2,R3 leaf

Telemetry Events

NABLA Compliance

Red Team operations both test and comply with the NABLA Infinity framework. Red simulations test the platform's adherence to NABLA axioms while the Red Team itself operates in compliance with all seven axioms.

Performance Metrics

Integration Points

Signal Flow

flowchart LR
    Gray["Gray Team Findings"]
    Black["Black Team Models<br/>(filtered)"]
    Red["Red Team"]
    Purple["Purple Team<br/>(Synthesis)"]
    Blue["Blue Team<br/>(Defense)"]
    White["White Team<br/>(Verification)"]

    Gray --> Red
    Black --> Red
    Red --> Purple
    Red --> Blue
    Red --> White

    classDef input fill:#0f172a,stroke:#475569,color:#e2e8f0
    classDef red fill:#1e293b,stroke:#dc2626,color:#fff
    classDef output fill:#0f172a,stroke:#10b981,color:#fff
    class Gray,Black input
    class Red red
    class Purple,Blue,White output

Outputs

Related Resources

• Blue Team — Primary consumer of Red Team findings for defense development
• Purple Team — Synthesis hub for Red-Blue loop closure
• Gray Team — Boundary exploration that seeds Red Team scenarios
• Black Team — Theoretical threat models that inspire Red simulations
• White Team — Formal verification of defenses against Red findings
• Real-Time Monitoring — Detection infrastructure tested by Red Team
• Quality Gates — Quality enforcement validated against adversarial pressure

Connect & Contribute

Created by Tomáš Korcak (korczis) | Open Source under GHL

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