Purple8-platform

🏗️ Purple8 Builder (Smart Pipeline)

AI-Powered Solution Builder with Intelligent Agent Orchestration

What is Purple8 Builder?

Purple8 Builder is an revolutionary AI system that transforms your ideas into complete, production-ready software solutions. Instead of one AI writing code, 58+ specialized AI agents collaborate—each expert in their domain—to deliver professional-grade results.

Think of it as having an entire software team at your fingertips:

🎯 How It Works

Traditional AI Coding

You: "Build me an e-commerce app"
ChatGPT: [Returns a single code file that won't actually work]

Purple8 Builder

You: "Build me an e-commerce app"
Purple8 Builder:
  
  📋 Phase 1: CONCEPTION
  └─ Ideation Agent → Full requirements document
  
  🎨 Phase 2: PLANNING  
  ├─ Design Agent → UI/UX wireframes
  ├─ Architecture Agent → System design
  └─ Database Agent → Schema + migrations
  
  💻 Phase 3: IMPLEMENTATION
  ├─ API Development Agent → REST/GraphQL contracts
  ├─ Frontend Agent → Vue.js/React components
  ├─ Backend Agent → FastAPI/Node services
  └─ Infrastructure Agent → Docker + Kubernetes
  
  🧪 Phase 4: QUALITY ASSURANCE
  ├─ Unit Test Agent → Test coverage
  ├─ Integration Test Agent → API tests
  ├─ Security QA Agent → Vulnerability scan
  └─ UAT Agent → User acceptance tests
  
  🚀 Phase 5: DELIVERY
  ├─ DevOps Agent → CI/CD pipelines
  ├─ Deployment Agent → Cloud deployment config
  └─ Observability Agent → Monitoring setup
  
  ✅ OUTPUT: Complete, deployable application

🧠 Smart Orchestration

Purple8 Builder doesn’t run all 58+ agents for every project. It’s intelligent:

Project Analysis

When you describe your project, the Smart Orchestrator analyzes:

Intelligent Agent Selection

Example 1: Simple REST API

Project: "Build a user authentication API"

Selected Agents (11):
✓ Ideation → Design → Architecture → Database
✓ API Development → Backend Development  
✓ Unit Test → Integration Test → Security QA
✓ DevOps → Deployment

Skipped: Frontend, Mobile, AI/ML agents (not needed)

Example 2: Full E-commerce Platform

Project: "Build a full-stack e-commerce platform with recommendation engine"

Selected Agents (25):
✓ ALL foundational agents
✓ Frontend Development (Vue.js store)
✓ Backend Development (FastAPI)
✓ Mobile Agent (responsive design)
✓ AI/ML Agent (recommendations)
✓ RAG Agent (product search)
✓ Full QA suite
✓ Security + Guardrails
✓ Complete DevOps

Purple8 Graph — Dynamic Agent Selection

Agent selection is powered by the Purple8 Graph Engine (services/knowledge_graph/agent_selection_graph.py), a custom vector-native knowledge graph that replaces all legacy vector databases.

How it works:

  1. KG Loader (kg_loader.py) populates all 58+ agents as graph nodes with DEPENDS_ON, BELONGS_TO_PHASE, BELONGS_TO_CATEGORY, and FOLLOWS_IN_SEQUENCE edges
  2. Agent Selection Graph enriches the hardcoded agent graph with live data from Purple8 Graph via get_all_agents() and get_all_dependencies()
  3. For each user prompt, get_agents_for_task() runs a hybrid search (vector similarity + graph neighbourhood traversal) to find the most relevant agents
  4. find_agent_execution_path() traverses FOLLOWS_IN_SEQUENCE edges to determine execution order
  5. get_agent_dependencies() traverses DEPENDS_ON edges to ensure prerequisites run first

Key principle: The journey does NOT always start with ideation — the graph determines the optimal entry point:

Solution Recall — Learning from Past Builds

The Solution Library (solution_library.py) + Build Recall Service (build_recall.py) use Purple8 Graph to learn from every completed build:

Phase What Happens
Pre-run BuildRecallService.pre_run_recall(prompt) runs a vector search over past Solution nodes, finds similar builds, and injects context snippets into the pipeline prompt
Post-run BuildRecallService.post_run_save(session_id, prompt, agent_outputs) persists the completed build as a new Solution node with embeddings, tech stack, and metadata

This means every build makes the next one smarter — agents receive context like: “Similar past build: FastAPI + PostgreSQL REST API (score: 0.92, tech: python, fastapi, postgres)”

✏️ Monaco Editor — HITL Code Review

The HITL approval workflow uses Monaco Editor (VS Code’s editor engine) for all code review and inline editing.

How It Works

When an agent produces output and enters the HITL approval queue:

  1. Raw Output Tab — MonacoCodeEditor renders the output with full syntax highlighting, auto-detecting language from agent name (e.g., architecture → YAML, database → SQL, backend → Python)
  2. Edit Mode — Reviewers toggle ✏️ to make inline edits directly in the Monaco editor; edits are captured as HITL feedback for rework cycles
  3. Diff Tab — MonacoDiffViewer shows side-by-side or inline diff comparing the previous version against the current agent output, with change count badges and unchanged region folding

Components

Component Used In Purpose
MonacoCodeEditor HITLReviewPanel, AgentOutputViewer Full editor: copy, format, language selector, fullscreen, read-only or editable
MonacoDiffViewer HITLReviewPanel Diff viewer: side-by-side / inline toggle, change statistics, version comparison

Supported languages: JSON, YAML, Markdown, Python, TypeScript, JavaScript, SQL, HTML, CSS, Shell.

📊 The 58+ Agent Catalog

🎯 Conception Phase

| Agent | Purpose | |——-|———| | Ideation | Analyzes requirements, creates user stories, defines scope |

📐 Planning Phase

| Agent | Purpose | |——-|———| | Design | UI/UX wireframes, component library, user flows | | Architecture | System design, component relationships, tech stack | | Database | Schema design, migrations, indexes, ORM models | | AI Engineering | ML architecture for AI-enabled projects | | Data Science | Data pipeline and analytics design |

💻 Implementation Phase

Core Development: | Agent | Purpose | |——-|———| | API Development | REST/GraphQL API contracts and documentation | | Frontend Development | Vue.js, React, or Angular components | | Backend Development | FastAPI, Node.js, or Django services | | Infrastructure Development | Docker, Kubernetes, cloud configs | | Mobile Development | React Native, Flutter, native code |

AI/ML Agents: | Agent | Purpose | |——-|———| | Machine Learning | ML model code and training pipelines | | NLP | Natural language processing components | | Computer Vision | Image/video processing | | RAG | Retrieval-augmented generation systems | | Chatbot | Conversational AI implementations | | Prompt Engineering | LLM prompt optimization |

Data & Analytics: | Agent | Purpose | |——-|———| | Dashboard | Data visualization components | | Data Engineering | ETL pipelines and data processing | | Graph Analytics | Knowledge graph implementations |

🧪 Quality Assurance Phase

| Agent | Purpose | |——-|———| | Unit Test | Unit tests with >80% coverage | | Integration Test | API and service integration tests | | SIT | System integration testing | | UAT | User acceptance test scenarios | | Performance QA | Load testing and optimization | | Security QA | Vulnerability scanning, OWASP checks | | Accessibility QA | WCAG compliance testing |

🚀 Delivery Phase

| Agent | Purpose | |——-|———| | DevOps | CI/CD pipelines (GitHub Actions, GitLab) | | Deployment | Cloud deployment configurations | | Software Packaging | Docker images, packages | | Observability | Logging, metrics, tracing setup |

🔐 Safety Phase

| Agent | Purpose | |——-|———| | Guardrails | AI safety constraints | | Security Risk | Threat modeling and risk assessment | | Legal | License compliance, ToS generation | | Compliance | Regulatory compliance checks |

🚀 Getting Started

Quick Start: Web App

You: "Build a task management web app with user authentication"

Purple8 Builder analyzes → selects 15 agents → executes in dependency order

Output:
📁 project/
├── 📄 REQUIREMENTS.md          (from Ideation Agent)
├── 📄 DESIGN_SPEC.md           (from Design Agent)
├── 📄 ARCHITECTURE.md          (from Architecture Agent)
├── 📁 database/
│   ├── schema.sql              (from Database Agent)
│   └── migrations/
├── 📁 backend/
│   ├── main.py                 (from Backend Agent)
│   ├── api/
│   ├── models/
│   └── tests/                  (from Unit Test Agent)
├── 📁 frontend/
│   ├── src/
│   │   ├── components/         (from Frontend Agent)
│   │   └── views/
│   └── package.json
├── 📁 infrastructure/
│   ├── Dockerfile              (from Infrastructure Agent)
│   ├── docker-compose.yml
│   └── kubernetes/
├── 📁 ci-cd/
│   └── .github/workflows/      (from DevOps Agent)
└── 📄 SECURITY_REPORT.md       (from Security QA Agent)

API Usage

# 1. Analyze project and get recommended agents
POST /api/pipeline/analyze
{
  "description": "Build a task management web app",
  "requirements": ["user auth", "task CRUD", "due dates"]
}

# Response: Recommended agents and execution plan

# 2. Execute the pipeline
POST /api/pipeline/execute
{
  "project_id": "proj-123",
  "agents": ["ideation", "design", "architecture", ...],
  "mode": "full"
}

# Response: Streaming agent outputs

🎛️ Execution Modes

Mode Description Use Case
Full Run all recommended agents New projects
Incremental Run only changed agents Updates
Phase Run specific phase only Testing phase only
Single Run one agent Quick fixes

📈 Example Projects Built

1. SaaS Dashboard

Input: "Build an analytics dashboard SaaS"
Agents: 22 agents
Output: Full-stack Vue + FastAPI + PostgreSQL app
Time: ~15 minutes

2. Mobile E-commerce

Input: "Mobile-first e-commerce with AI recommendations"
Agents: 28 agents (including ML, Mobile)
Output: React Native + FastAPI + ML pipeline
Time: ~25 minutes

3. Healthcare Portal

Input: "HIPAA-compliant patient portal"
Agents: 30 agents (extra security, compliance)
Output: Secure full-stack with audit logging
Time: ~30 minutes

🔧 Technical Architecture

┌─────────────────────────────────────────────────────────────────┐
│                     Purple8 Builder                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌─────────────┐    ┌─────────────────┐    ┌────────────────┐  │
│  │   Project   │───▶│ Project         │───▶│ Smart          │  │
│  │   Input     │    │ Analyzer        │    │ Orchestrator   │  │
│  └─────────────┘    └─────────────────┘    └───────┬────────┘  │
│                            │                        │           │
│                            ▼                        ▼           │
│                     ┌─────────────┐         ┌─────────────┐    │
│                     │ Domain      │         │ Agent Pool  │    │
│                     │ Detection   │         │ (58+ agents)│    │
│                     │ • Web       │         │             │    │
│                     │ • Mobile    │         │ Conception: │    │
│                     │ • AI/ML     │         │  - Ideation │    │
│                     │ • Data      │         │             │    │
│                     │ • Security  │         │ Planning:   │    │
│                     └─────────────┘         │  - Design   │    │
│                            │                │  - Arch     │    │
│                            ▼                │  - Database │    │
│                     ┌─────────────┐         │             │    │
│                     │ Purple8     │         │ Implement:  │    │
│                     │ Graph       │         │  - Frontend │    │
│                     │ Engine      │         │  - Backend  │    │
│                     │             │         │  - AI/ML    │    │
│                     │ • Agent     │         │             │    │
│                     │   graph     │         │ QA:         │    │
│                     │ • Vector    │         │  - Tests    │    │
│                     │   search    │         │  - Security │    │
│                     │ • Solution  │         │             │    │
│                     │   recall    │         │ Delivery:   │    │
│                     │ • Journey   │         │  - DevOps   │    │
│                     │   tracking  │         │  - Deploy   │    │
│                     └─────────────┘         └─────────────┘    │
│                            │                       │           │
│                            ▼                       ▼           │
│                     ┌─────────────────────────────────────┐    │
│                     │   HITL Review (Monaco Editor)       │    │
│                     │   Code viewer + Diff viewer         │    │
│                     │   Inline editing → feedback loop    │    │
│                     └──────────────┬──────────────────────┘    │
│                                    ▼                           │
│                     ┌─────────────────────────────────────┐    │
│                     │      Complete Project Output        │    │
│                     │  (Code + Docs + Tests + Configs)    │    │
│                     └─────────────────────────────────────┘    │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

🎯 Best Practices

  1. Be Specific: More detail = better output
    • ❌ “Build an app”
    • ✅ “Build a task management app with user auth, due dates, notifications, and team sharing”
  2. Specify Tech Stack (optional): If you have preferences
    • “Use PostgreSQL and Vue.js”
    • “Deploy to AWS with Terraform”
  3. Include Constraints: Security, compliance, scale
    • “Must be HIPAA compliant”
    • “Support 10,000 concurrent users”
  4. Iterate: Use incremental mode to refine
    • Run full pipeline first
    • Then “Add calendar integration” in incremental mode

💰 Pricing

Plan Projects/Month Price
Free 3 projects $0
Pro 20 projects $49/month
Team 100 projects $199/month
Enterprise Unlimited Custom

1 project = 1 full pipeline execution

🔗 Related Documentation

Questions? Contact support@purple8.ai

© 2025-2026 Purple8.ai. All Rights Reserved.