Academy

Perex

The Prismatic Academy provides comprehensive structured learning paths that take developers from initial platform orientation through mastery of autonomous agent development, epistemic reasoning systems, and production-grade architecture. This living curriculum evolves with the platform itself, incorporating lessons from Lab experiments, production patterns, and developer community feedback.

Built on progressive disclosure, hands-on primacy, and production realism, every theoretical concept includes executable code with observable results using the same quality standards that govern the production platform.

Key Academy Resources

15+ Courses • 3 Learning Tracks • 40+ Hours Content • 60% Hands-On

The Academy spans beginner through advanced tracks with progressive skill development, comprehensive assessments, and certification pathways. Each course integrates with Lab experimentation and API documentation, forming a triangle of learning resources that reinforces understanding from multiple angles.

Learning Track Structure

Academy Statistics

• Total Courses: 15+ comprehensive learning modules
• Learning Tracks: 3 progressive skill development paths
• Content Duration: 40+ hours of structured educational content
• Hands-On Ratio: 60% practical exercises and code examples
• Assessment System: Prerequisite enforcement with proficiency verification
• Certification: Available for completed track mastery
• Integration: Tight coupling with Lab and API resources

Quick Navigation

• Lab Experiments - Hands-on experimentation complementing Academy theory
• API Reference - Technical documentation for Academy concepts
• Agent System - 531 agents that students learn to build and orchestrate
• Platform Capabilities - Core doctrines taught throughout curriculum
• Developer Portal - Tools and resources for Academy students

Explore Platform

Want to Know More?

Start with the beginner track for platform foundations, explore intermediate concepts for multi-agent orchestration, or dive into advanced topics for security and formal verification.

About Academy: Learning Philosophy • Track Structure • Assessment System

Overview

The curriculum spans 15 courses organized across three tracks, totaling over 40 hours of structured content. Each course combines explanatory text, annotated code examples, guided exercises, and assessment checkpoints. The Academy integrates tightly with the Lab for hands-on experimentation and the API for reference documentation, forming a triangle of learning resources that reinforces understanding from multiple angles.

The Academy does not assume prior experience with the Prismatic Platform, but it does assume baseline programming competence. Developers comfortable with at least one general-purpose programming language and familiar with basic concepts like version control, HTTP APIs, and relational databases will find the beginner track immediately accessible.

Learning Path Architecture

The Academy organizes its curriculum into three progressive tracks. Each track builds on the knowledge established by the previous one, though experienced developers may skip ahead if they can demonstrate proficiency through the assessment system.

The track structure is not merely organizational convenience. It reflects a deliberate pedagogical design that matches the cognitive load of each topic to the learner's preparation. Agent orchestration, for example, requires understanding individual agent behavior first; NABLA Infinity requires understanding why epistemic rigor matters before diving into axiom enforcement. The tracks encode these dependencies.

Beginner Track (12 hours): Platform foundations, first agent, quality standards, development workflow, OTP fundamentals. The learner emerges able to navigate the codebase, build simple agents, and contribute code that passes quality gates.

Intermediate Track (16 hours): Agent orchestration, NABLA Infinity, storage patterns, LiveView dashboards, AIAD standard. The learner emerges able to design multi-agent systems, implement epistemic validation, and build production dashboards.

Advanced Track (12+ hours): Color Team security, EASM development, formal verification, evolution patterns, API integration. The learner emerges able to contribute to the platform's most sophisticated subsystems and lead architectural decisions.

Beginner Track

The beginner track establishes the foundational knowledge required to work productively within the Prismatic Platform. It assumes no prior platform experience and introduces concepts in a carefully sequenced order.

Platform Overview

The opening course orients learners to the platform's umbrella architecture, the role of OTP in providing fault tolerance and concurrency, and the organization of the 90+ applications that comprise the system. Learners explore the codebase structure, understand how applications depend on each other, and learn to navigate using the git-trees tooling that provides fast indexed access to the entire file tree.

# Understanding umbrella structure
# Each app in apps/ is an independent OTP application
# with its own supervision tree, configuration, and tests

# List all applications
Mix.Project.apps_paths()
# => %{prismatic: "apps/prismatic", prismatic_web: "apps/prismatic_web", ...}

# Each app declares its dependencies explicitly
defp deps do
  [
    {:prismatic_storage_core, in_umbrella: true},
    {:prismatic_agents, in_umbrella: true}
  ]
end

First Agent

This course guides learners through building their first AIAD-compliant autonomous agent. Starting from the agent specification format, learners implement a simple agent that monitors a data source, applies a transformation, and emits results. The course emphasizes OTP process design, supervision strategies, and the message-passing patterns that agents use to communicate.

Quality Standards

The quality standards course introduces the NO MERCY, NO DOUBTS doctrine and its practical implications. Learners understand why the platform maintains zero-warning compilation, 100% typespec coverage, and mandatory regression tests. They practice running the quality gate toolchain (mix compile --warnings-as-errors, mix credo --strict, mix test --cover) and learn to interpret and resolve violations.

Development Workflow

This course covers the practical mechanics of contributing to the platform: git workflow conventions, commit message standards, the CI/CD pipeline, pre-commit hooks, and the session discipline protocol. Learners set up their development environment, make a practice contribution, and verify that it passes all quality gates.

OTP Fundamentals

The OTP fundamentals course provides a focused introduction to the OTP behaviours that underpin the platform: GenServer for stateful processes, Supervisor for fault tolerance, and Application for lifecycle management. Rather than covering OTP in abstract, this course teaches it through platform-specific examples, showing how real Prismatic modules use these patterns.

defmodule MyAgent.Server do
  use GenServer

  @impl true
  def init(config) do
    schedule_check(config.interval)
    {:ok, %{config: config, last_check: nil, findings: []}}
  end

  @impl true
  def handle_info(:check, state) do
    case perform_check(state.config) do
      {:ok, findings} ->
        schedule_check(state.config.interval)
        {:noreply, %{state | last_check: DateTime.utc_now(), findings: findings}}

      {:error, reason} ->
        Logger.warning("Check failed: #{inspect(reason)}")
        schedule_check(state.config.retry_interval)
        {:noreply, state}
    end
  end

  defp schedule_check(interval), do: Process.send_after(self(), :check, interval)
end

Intermediate Track

The intermediate track builds on the beginner foundation to address production-scale concerns: multi-agent coordination, epistemic validation, diverse storage backends, real-time interfaces, and the AIAD standard that governs all autonomous components.

Agent Orchestration

This course teaches the patterns for coordinating multiple agents to accomplish complex objectives. Topics include the supreme orchestrator pattern, agent dependency graphs, message routing strategies, and failure handling in multi-agent workflows. Learners implement a multi-agent pipeline that processes data through several specialized agents and produces a consolidated result.

NABLA Infinity

The NABLA Infinity course is one of the Academy's most distinctive offerings. It teaches the platform's epistemic framework: the seven non-negotiable axioms (Signal Plurality, Contradiction Preservation, Absence Informative, Time Decay, Unknown Valid, Source Independence, Provenance Mandatory), the Trinity Gate's three-layer validation, and the confidence threshold system. Learners implement axiom enforcement in practice scenarios and experience firsthand how the framework prevents common reasoning errors.

Storage Patterns

This course covers the platform's multi-backend storage architecture. Learners work with PostgreSQL for relational data, ETS for fast in-memory state, KuzuDB for graph relationships, and Meilisearch for full-text search. The course emphasizes the adapter pattern that provides a uniform interface across backends, and teaches learners to select the appropriate storage technology for different data characteristics.

LiveView Dashboards

The LiveView dashboards course teaches the construction of real-time monitoring interfaces using Phoenix LiveView, TailwindCSS, and Flowbite components. Learners build a dashboard that displays live telemetry data, handles user interactions, and updates in real-time without page reloads. The course covers LiveView lifecycle, socket assigns, live components, and the platform's dashboard design conventions.

AIAD Standard

This course provides a comprehensive introduction to the Autonomous Intelligence Agent Design standard that governs all autonomous components on the platform. Topics include agent specification format, command specification format, pipeline design, policy enforcement, and the relationship between AIAD specifications and their runtime implementations. Learners author complete AIAD specifications for agents they have built.

Advanced Track

The advanced track addresses the platform's most sophisticated subsystems and prepares learners to make architectural contributions. Courses at this level assume solid understanding of the beginner and intermediate material.

Color Team Security

This course teaches the platform's adversarial-defensive security model. Learners understand the roles of all six color teams (Gray, Red, Blue, Purple, White, Black), the signal flow architecture between teams, and the safety protocols that constrain security research. Practical exercises involve designing Gray team boundary explorations, simulating Red team scenarios with synthetic data, and evaluating Blue team defensive postures.

EASM Development

The External Attack Surface Management course covers the Perimeter module's architecture: asset discovery, security rating calculations (A-F grading with numeric scores), compliance assessment against NIS2 and ZKB frameworks, and the LiveView dashboard that presents findings. Learners implement a custom scanner that discovers a new asset type and integrates it into the rating pipeline.

Formal Verification

This course introduces the platform's formal verification capabilities, including property-based testing with StreamData, the QEVE (Lean4 + NABLA + Monte Carlo) verification engine, and the White Team's progressive verification methodology (L0-L5). Learners write property-based tests for existing modules and explore how formal proofs complement traditional testing.

Evolution Patterns

The evolution patterns course examines the platform's self-evolving capabilities: the autoheal system, the autoevolve scanner, quality floor guardians, and the generation-based fitness tracking that has carried the platform from Generation 1 to Generation 18. Learners understand how the platform identifies improvement opportunities and applies them autonomously.

API Integration

This course teaches advanced usage of the platform's auto-introspecting API, covering topics beyond basic endpoint consumption: custom type mapping, webhook integration, rate limit management, batch operations, and the process by which Lab experiments graduate to become API endpoints. Learners build a client library that consumes the API programmatically.

Pedagogical Approach

The Academy's pedagogical approach has been refined through iterative application and draws on established principles of technical education.

Progressive Disclosure

Concepts are introduced at the level of abstraction appropriate to the learner's current understanding. The beginner track, for example, teaches agents as "processes that do work on a schedule" before revealing the full OTP supervision machinery underneath. Each layer of abstraction is only peeled back when the learner has demonstrated competence at the current level.

Hands-On Primacy

Every course maintains a minimum 60% hands-on ratio. Theory sections are kept concise and are immediately followed by executable examples. Learners are expected to run code, observe results, modify parameters, and verify their understanding through experimentation. The Lab provides the sandboxed environment for experiments that exceed the scope of inline exercises.

Spaced Repetition

Key concepts are revisited across multiple courses at increasing levels of sophistication. OTP supervision, for example, is introduced in the beginner track, applied to multi-agent systems in the intermediate track, and analyzed in the context of self-healing evolution in the advanced track. This repetition ensures deep retention of fundamental concepts.

Real-World Grounding

All examples use production patterns. There are no toy examples that teach techniques inapplicable to real work. When a course demonstrates an agent, it uses the AIAD specification format. When it demonstrates a query, it uses the platform's actual storage adapter interface. This ensures that skills transfer seamlessly from Academy exercises to production contributions.

Prerequisites and Skill Matrix

Each track defines clear prerequisites that learners should satisfy before beginning.

Beginner Track Prerequisites: Proficiency in at least one programming language. Familiarity with git version control. Basic understanding of HTTP and REST APIs. Comfort with a terminal/command-line environment. No Elixir experience required; the track teaches the necessary Elixir/OTP concepts.

Intermediate Track Prerequisites: Completion of the beginner track or equivalent demonstrated knowledge. Working familiarity with Elixir syntax and OTP basics. Ability to build and test simple GenServer processes. Understanding of the platform's quality gate workflow.

Advanced Track Prerequisites: Completion of the intermediate track or equivalent demonstrated knowledge. Ability to design multi-agent systems. Understanding of the NABLA Infinity axioms. Familiarity with at least two storage backends. Experience with LiveView or equivalent real-time web framework.

The Academy provides a self-assessment tool that evaluates a learner's current skill level and recommends the appropriate starting point. Learners who believe they can skip a track can take the track's final assessment; a passing score grants credit and advancement.

Interactive Livebook Ecosystem

The Academy is complemented by a 100-notebook interactive Livebook ecosystem spanning all platform domains. These computational notebooks provide hands-on practice with real-time visualization, live BEAM VM introspection, and distributed node connectivity.

Livebook Learning Paths by Domain

Livebook-Academy Integration

Every livebook connects to the platform via distributed Erlang (Node.connect/1), enabling real-time introspection of running systems. Features include:

• Interactive Kino Widgets: Dropdowns, sliders, buttons, text inputs for parameter configuration
• Real-time VegaLite Charts: Live-updating visualizations with push-based data streaming
• BEAM VM Introspection: Direct access to :erlang.memory/0, Process.list/0, :ets.all/0
• Cross-Domain References: Each livebook links to related Glossary terms, Lab experiments, and Academy courses
• Platform Connectivity: Node.connect(:"prismatic@127.0.0.1") for live distributed operation

Recommended Livebook Sequences

For Beginners: Start with Storage & Data → Platform Administration → Data Analysis For Security Focus: Security & Compliance → OSINT & Intelligence → AI & Agents (Color Team) For Developers: API & Integration → Quality & Testing → Performance & Monitoring For Data Scientists: Data Analysis → OSINT & Intelligence → Academy & Learning

All livebooks are located in livebooks/domains/ within the platform repository.

Lab Integration

The Academy maintains a bidirectional integration with the Lab that enriches both components.

Academy courses reference real Lab experiments as case studies. When a course teaches pipeline optimization, it can point to a specific Lab experiment that benchmarked different pipeline topologies, showing real data and real conclusions. This grounding in actual experimental results gives Academy content an authority that purely theoretical material lacks.

In the reverse direction, when Academy students encounter questions that existing materials cannot answer, those questions may seed new Lab experiments. If multiple students ask "how does axiom enforcement perform at 10x the normal load?" and no existing data addresses this, the question becomes a Lab hypothesis.

Intermediate and advanced courses include Lab exercises where learners design and execute experiments in the Lab's sandboxed environment. These exercises teach not only the course's subject matter but also the experimental methodology skills that the Lab demands: hypothesis formulation, controlled execution, rigorous analysis, and clear reporting.

API Integration

The API serves as the Academy's definitive reference layer. Every concept taught in the Academy has a corresponding API surface that learners can explore interactively.

When an Academy course introduces a capability such as security rating calculation, it teaches the concepts, motivation, and design behind the feature. The API reference then provides the precise endpoint specification, request/response schemas, error codes, and usage examples. This two-layer approach separates understanding (Academy) from specification (API), allowing each to serve its purpose without compromise.

# Academy teaches the concept of asset discovery
# API provides the executable specification

# After learning about EASM in the Academy, learners can immediately
# interact with the real API:
curl -X POST http://localhost:4004/api/v1/perimeter/discover \
  -H "Authorization: Bearer $API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domain": "example.com"}'

# The API's auto-generated OpenAPI spec at /api/openapi
# serves as the authoritative reference for every endpoint

Academy courses that involve API interaction include a "Reference" sidebar that links directly to the relevant API endpoint documentation. This tight coupling ensures that learners always know where to find precise specifications for the concepts they are studying.

Assessment and Certification

The Academy employs a multi-layered assessment approach to verify genuine understanding rather than surface familiarity.

Knowledge Checks

Each course section concludes with brief knowledge checks that verify comprehension of the material just covered. These are not graded formally but serve as self-assessment tools that help learners identify gaps before proceeding.

Practical Exercises

Each course includes practical exercises that require learners to write code, run experiments, or analyze scenarios. Exercises are auto-graded where possible, with manual review for open-ended submissions. The exercise system provides immediate feedback with explanations of correct approaches.

Track Assessments

At the conclusion of each track, learners complete a comprehensive assessment that covers the entire track's material. Track assessments combine multiple-choice questions for concept verification with practical coding challenges that test applied skill. A minimum score of 80% is required to earn track completion credit.

Certification

Learners who complete all three tracks and pass their assessments receive Prismatic Platform certification. Certification indicates demonstrated competence across the full spectrum of platform capabilities, from basic agent construction through advanced security operations and formal verification. Certification is valid for one year, after which learners must pass an updated assessment to renew, ensuring that certified practitioners remain current with platform evolution.

Proficiency Levels

The certification system recognizes three proficiency levels that correspond to the tracks:

Community and Contribution

The Academy is a community resource, and its quality depends on contributions from practitioners across the platform ecosystem.

Contributing Tutorials

Developers who discover effective patterns, resolve non-obvious problems, or develop novel approaches are encouraged to contribute Academy content. Contributed tutorials follow the same structure as core courses: clear learning objectives, progressive concept introduction, executable code examples, and assessment checkpoints.

Feedback and Improvement

Every Academy page includes a feedback mechanism that captures learner experience. Common areas of confusion are flagged for content revision. Suggestions for new courses are reviewed quarterly and prioritized based on demand and strategic alignment.

Mentorship

The Academy supports a mentorship model where advanced-track graduates can volunteer as mentors for learners in earlier tracks. Mentors provide guidance on exercises, review practical submissions, and share production experience that enriches the Academy's theoretical content.

Content Freshness

Academy content is reviewed and updated on a quarterly cycle to reflect platform changes. When the platform introduces new capabilities, the Academy team assesses which courses need updating and creates new content where necessary. The Lab provides a continuous stream of new experimental results that feed into course updates, and the API reference layer updates automatically as new endpoints are discovered.

The Academy's goal is not merely to document the platform but to accelerate mastery. Every design decision, from track structure to assessment methodology, serves this goal. Developers who complete the Academy curriculum are not just informed about the platform; they are prepared to contribute to its evolution.

Connect & Contribute

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

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