About Prismatic

Perex

Prismatic Platform is the world's most advanced open source intelligence platform - a complete reimagining of what software development can become. Created by Tomáš Korcak (korczis), this GPL-3.0 licensed ecosystem comprises 2.8 million lines of production-grade Elixir/OTP code, 531 autonomous agents, and 106 applications working in concert to create something unprecedented: a software platform that improves itself.

This is not another IDE plugin, copilot, or code generator. Prismatic is an epistemic development operating system where every decision is traceable, every claim is verified, every contradiction is preserved, and every line of code passes through formal quality gates with zero exceptions.

Key Platform Resources

531 Autonomous Agents • 106 Applications • 2.8M+ Lines of Code • 100/100 Quality Score

The platform orchestrates specialized AI agents across operational domains, from strategic command to tactical execution, creating a system where autonomous agents handle development with human strategic direction. Every component adheres to the NO MERCY, NO DOUBTS doctrine that governs all platform operations.

Platform Components

Platform Statistics

• Total Codebase: 2.8M+ lines of production-grade Elixir/OTP code
• Agent Network: 531 autonomous entities across 16 operational domains
• Quality Score: 100/100 across 13 measurement domains (PERFECT)
• Applications: 106 umbrella applications in coordinated ecosystem
• License: GPL-3.0 (Full transparency, zero restrictions)
• Creator: Tomáš Korcak (korczis) with direct community access
• Governance: NO MERCY, NO DOUBTS doctrine (zero compromise)

Quick Navigation

• Agent Ecosystem - 531 autonomous agents with specialized capabilities
• Platform Capabilities - Core doctrines and technical specifications
• Architecture Overview - System design and component relationships
• Developer Portal - Open source tools and community resources
• Applications Catalog - 625+ production application blueprints

Explore Platform

Want to Know More?

Explore the creator's philosophy, dive into the five pillars that define the platform, or understand why this represents a complete reimagining of software development.

About Prismatic: Origin and Philosophy • Platform Pillars • What Makes It Different

What is Prismatic Platform?

Created by Tomáš Korcak (korczis) / Sig Nihl

The Creator's Vision: "I built Prismatic Platform because the software industry accepts mediocrity as inevitable. We tolerate bugs, accept technical debt, and ship systems we know are flawed. This platform proves that perfect software is not only possible - it's the only acceptable standard." - Tomáš Korcak

Prismatic is an epistemic development operating system -- a platform where every decision is traceable, every claim is verified, every contradiction is preserved, and every line of code passes through formal quality gates before it exists in the codebase. It is built on Elixir/OTP, it runs 434 specialized AI agents, and it maintains a perfect 100/100 quality score across 13 measurement domains with zero exceptions.

The word "epistemic" is deliberate. Traditional development tools care about syntax, autocompletion, and test coverage. Prismatic cares about what you know, how confident you are in what you know, and whether your confidence is justified. It tracks signals, preserves contradictions, enforces evidence plurality, and refuses to let you merge code that is based on unverified assumptions.

What Prismatic Is NOT

Not an IDE extension. Prismatic does not live inside VS Code or IntelliJ. It is a standalone platform -- 99 umbrella applications, ~2.8 million lines of Elixir code, and a supervision tree that would make most distributed systems architects raise an eyebrow.

Not a copilot. Copilots suggest code. Prismatic orchestrates 552 agents across 14 domains -- from security simulation to formal verification to autonomous quality healing. It does not suggest; it decides, verifies, and enforces.

Not a code generator. Generating code is trivial. The hard problem is knowing whether the code should exist at all, whether it contradicts existing decisions, whether it introduces drift, and whether the reasoning behind it is sound. Prismatic solves the hard problem.

Not "AI-assisted development." That phrase implies a human doing development with AI help. Prismatic inverts the model: it is a system of autonomous agents doing development with human strategic direction. The human decides what; the platform decides how, validates why, and proves that the result is correct.

The Five Pillars

1. AI Orchestration (434 Agents, 14 Domains)

Prismatic does not have "an AI." It has 434 specialized agents organized across 14 domains, from strategic command (8 agents with cross-domain authority) to tactical execution (89 focused task agents) to intelligence operations (67 information gathering agents) to security operations (20 agents across 6 color teams). Each agent has a defined authority level, a specific competency, and a formal behavioral specification written in the AIAD standard.

These agents do not just answer questions. They orchestrate, verify, contradict each other, and converge on decisions that pass the Trinity Gate -- a three-layer formal verification system requiring structural consistency, logical consistency, and formal proof before any claim is established.

2. Security (Color Teams)

Security in Prismatic is not a checkbox. It is a continuous adversarial-defensive synthesis operated by 6 color teams with 20 specialized agents:

• Gray Team explores boundaries and specification gaps without resolving them
• Red Team simulates epistemic attacks in sandboxed environments with synthetic data only
• Blue Team synthesizes defensive evidence grounded in NABLA axioms
• Purple Team closes the loop between Red and Blue, detecting false closures and regression traps
• White Team generates formal proofs and validates interface contracts
• Black Team produces abstract threat models under maximum isolation (never executable output)

All adversarial operations run in sandboxes. No real data. No network access. Ethics checks every 10-15 seconds. This is not penetration testing theater -- it is structured epistemic security research embedded directly into the development process.

3. Quality (100/100 Perfect Score)

Prismatic maintains a perfect quality score across 13 measurement domains: Dialyzer type safety, Credo code quality, zero-warning compilation, DateTime precision, guard function safety, @impl behavior coverage (709 implementations), memory safety, performance benchmarks, regression prevention, timing pattern consistency, TODO management, typespec coverage, and safe map access. Zero violations in every domain.

This is not aspirational. It is enforced. The NO MERCY doctrine blocks commits that introduce warnings, incomplete implementations, stubs, mocks, placeholders, TODOs, or FIXMEs. The Quality Floor Guardian monitors quality autonomously and triggers auto-evolution when scores approach thresholds. Every bug fix requires a mandatory regression test that must fail before the fix and pass after -- no exceptions, no bypass.

4. Formal Verification (QEVE + Trinity Gate)

Most AI platforms give you a confidence percentage. Prismatic gives you a formally verified conclusion. The QEVE (Quantified Epistemic Verification Engine) combines Lean4 formal proofs, NABLA epistemic axioms, and Monte Carlo robustness testing into a five-stage verification pipeline.

The Trinity Gate requires every established claim to pass three independent checks: structural consistency (graph theory -- the belief network forms a valid DAG), logical consistency (rule-based -- propositions follow logical rules), and formal necessity (modal logic + Lean4 proofs). No claim is established without Trinity passage.

This matters for compliance. When an auditor asks "why did the system make this decision?", the answer is not "the model said 87%." The answer is a traceable chain of evidence, axiom compliance, and formal proof.

5. Self-Evolution (Generation 18)

Prismatic evolves autonomously. The platform has progressed from Generation 1 to Generation 18 through systematic self-improvement cycles. The SEADF framework (7 subsystems: Scanner, Pipeline, Quality Guardian, Knowledge Sync, Cross-Domain Innovator, Autonomous Reporter, Enhanced Healing) continuously identifies improvement opportunities, applies them, and validates results.

Current evolution fitness: 0.999 (apex). The platform has 11 consciousness traits, 7 NABLA axioms enforced at all times, and 629 Trinity-verified entities. Quality Debt has been completely eliminated -- 0 QDP remaining from 905 originally identified patterns.

How Prismatic Differs from Traditional AI Tools

The current landscape of "AI for development" falls into a few categories. Understanding where Prismatic sits requires understanding what those categories are and why they are insufficient.

Category 1: Code Completion Tools (Copilot, Codeium, TabNine)

These tools predict the next tokens in your code based on context. They are sophisticated autocomplete. They do not understand your architecture, your design decisions, your security requirements, or your quality standards. They generate code that might work but that has no formal relationship to the correctness of your system.

Prismatic does not complete code. It verifies decisions. When a Prismatic agent generates code, that code passes through the same quality gates as human-written code: zero-warning compilation, Credo strict analysis, typespec coverage, regression test verification, and Trinity Gate validation. The agent does not get special treatment.

Category 2: Chat-Based Code Assistants (ChatGPT, Claude)

These tools answer questions about code. You describe a problem, they propose a solution. The interaction is fundamentally question-and-answer. There is no persistent state, no decision tracking, no contradiction preservation, and no formal verification of the answers.

Prismatic's 552 agents have persistent state (each agent is an OTP process with a lifecycle), formal behavioral specifications (AIAD standard), and verification requirements. They do not just answer questions -- they participate in a structured pipeline where their outputs are cross-validated, contradictions are preserved, and conclusions pass through Trinity Gate before being established.

Category 3: IDE-Integrated AI (Cursor, Windsurf)

These tools embed AI deeply into the editor experience. They understand your codebase context and can make multi-file changes. They are the most advanced of the traditional AI tools, but they still operate within the "assistant" paradigm: the human drives, the AI assists.

Prismatic inverts this. The platform drives the development process. The human provides strategic direction (what to build, what to prioritize), and the platform handles execution with 434 specialized agents, each operating within formal specifications. The human does not need to prompt the quality gates to run -- they run automatically. The human does not need to ask for regression tests -- they are mandatory.

Category 4: DevSecOps Platforms (Snyk, Veracode, Checkmarx)

These platforms add security scanning to CI/CD pipelines. They find vulnerabilities in dependencies, source code, and container images. They are valuable but reactive -- they scan after the code is written.

Prismatic's Color Teams operate continuously, not as a pipeline stage. The Gray Team discovers specification gaps before code is written. The Red Team simulates attacks against the design, not just the implementation. The White Team proves security properties formally. This is proactive security integrated into the development model, not reactive scanning bolted onto the deployment pipeline.

Architecture at a Glance

Prismatic is an Elixir/OTP umbrella application with 99 apps, running on the BEAM virtual machine. The technology stack includes:

The codebase contains 6,652 .ex files (13,223 total Elixir files), approximately 2.8 million lines of code, 11,308 documentation entries, and 5,864 test files. Every module has a typespec. Every behavior callback has an @impl annotation. Every public function has documentation.

The Umbrella Structure

The 99 applications are not arbitrary divisions. They follow a domain-driven architecture where each application encapsulates a bounded context:

• Storage layer: prismatic_storage_core (traits and protocols), prismatic_storage_ets (in-memory), prismatic_storage_ecto (PostgreSQL), prismatic_storage_meili (search), prismatic_storage_kuzu (graph)
• Intelligence layer: prismatic_agents (434 agent runtime), prismatic_claude (session management), prismatic_safety (quality prediction)
• Security layer: prismatic_perimeter (EASM), prismatic_dark (adversarial sandbox)
• Web layer: prismatic_web (LiveView dashboards), prismatic_api (auto-introspecting REST API)
• Coordination layer: prismatic (main API), prismatic_supervisor (compositional supervision)

Each application has its own supervision tree, its own test suite, its own CLAUDE.md documentation, and its own quality DNA state. Applications communicate through well-defined protocols and behaviors -- never through shared mutable state.

Key Differentiators vs Traditional Platforms

Who Should Read What

This section contains perspectives tailored to different audiences:

• For Developers: How Prismatic transforms the developer experience with 400+ agents, regression enforcement, and epistemic proofs. If you write code, start here.
• For Architects: Prismatic as a runtime for decisions over code -- contradictions, signal plurality, confidence thresholds, and the 16-level epistemic pipeline. If you design systems, this is your entry point.
• For Executives: Prismatic as a decision engine that turns development into an auditable process. Every decision traced, every conclusion proved. If you care about risk and compliance, read this.
• For Security & Risk: Color Teams in your development process -- adversarial simulation, epistemic defense, formal proofs, and audit trails. If you think about threats and compliance, this is for you.
• QEVE Deep Dive: The technical architecture of the Quantified Epistemic Verification Engine. From "model says 87%" to auditable, legally defensible conclusions.

The NABLA Foundation

At the philosophical core of Prismatic sits the NABLA Infinity framework -- 7 non-negotiable epistemic axioms that govern how the platform forms, evaluates, and acts on beliefs:

1. Signal Plurality: No conclusion from a single data point. Minimum two independent signals required before any belief is formed. This prevents the single-source-of-truth failure mode that plagues most AI systems.

2. Contradiction Preservation: When evidence conflicts, both sides are kept. Premature resolution is forbidden. Most systems pick the "best" answer and discard the rest. Prismatic preserves the tension because contradictions contain information.

3. Absence Informative: The dog that did not bark matters. Missing expected signals are tracked as meaningful data. If a security scan should have found TLS certificates but found none, that absence is evidence.

4. Time Decay: All evidence has timestamps. Older evidence is weighted less. A vulnerability assessment from last month is worth less than one from today. The decay function is configurable by domain.

5. Unknown Valid: "I don't know" is a legitimate output. The system is never forced to produce an answer when the evidence is insufficient. Forced certainty is an anti-pattern that the platform actively prevents.

6. Source Independence: Independent sources carry more weight than correlated ones. Five reports from the same scanning tool count as one signal, not five. True plurality requires true independence.

7. Provenance Mandatory: Every belief must be traceable to its originating signals through every transformation step. If you cannot trace it, it does not exist in the epistemic pipeline.

These axioms are enforced programmatically. A hard axiom violation blocks the pipeline. The system literally cannot produce a conclusion that violates Signal Plurality or Provenance Mandatory. This is not a governance aspiration -- it is a code path constraint.

The Meta-Rule

There is one rule that governs all Prismatic development, and it is worth stating upfront because it explains the philosophy better than any architecture diagram:

If the same solution could be written identically in Node.js, it is WRONG.

Prismatic leverages Elixir/OTP because OTP provides things that no other runtime does: lightweight processes for every stateful entity, supervision trees for fault tolerance, hot code reloading for zero-downtime evolution, pattern matching for declarative logic, and the BEAM scheduler for massive concurrency. If you are not using these capabilities, you are writing a Node.js application in Elixir syntax, and that defeats the entire purpose.

This rule extends to the AI layer. If your AI integration is just "send prompt, receive response," you are building a chatbot, not an epistemic system. Prismatic's agents have formal specifications, authority levels, behavioral contracts, and verification requirements. They participate in a structured decision-making process with formal proofs. That is fundamentally different from autocomplete.

Origin and Philosophy

Prismatic emerged from two decades of work in OSINT (Open Source Intelligence), security research, and distributed systems engineering. The GARDEN legacy (22 repositories, 3,050+ files, 55+ patterns, 20+ years) provides the foundation -- 250+ OSINT providers, a Blackboard architecture for collaborative intelligence, KuzuDB graph database integration, and dozens of battle-tested patterns extracted from production systems.

The platform's name reflects its core function: like a prism separates white light into constituent wavelengths, Prismatic separates complex decisions into constituent evidence streams, analyzes each stream independently, and synthesizes them into verified conclusions. The separation is the point -- undifferentiated signals produce noise; structured analysis produces insight.

The NO MERCY, NO DOUBTS doctrine is not theatrical. It was born from real experience: incomplete implementations that became permanent, untested assumptions that became production bugs, deferred quality debt that compounded into architectural cancer. The doctrine exists because the consequences of its absence were measured and found unacceptable.

Further Reading

• Platform Architecture -- Technical deep dive into the OTP supervision tree and umbrella structure
• Agent Ecosystem -- The full registry of 434 AIAD agents
• Platform Capabilities -- Doctrines, quality systems, and governance frameworks
• Glossary -- 127 defined terms with precise meanings
• Color Teams -- Detailed breakdown of the 6 security teams

Connect & Contribute

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

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