ai.bs

[{
  "id": "ai-index-map",
  "title": "AI Systems",
  "abstract": "This index map represents the full series of AI value-chain maps as higher-level components, double click an item to navigate to that map.",
  "categories": [
    {
      "id": "domain-eng-apps",
      "title": "Domain & Engineering Applications",
      "items": [
        {
          "id": "ai-product-design",
          "name": "AI for Product Design",
          "deps": [
            "ai-augmented-workflows",
            "ai-knowledge-management"
          ]
        },
        {
          "id": "ai-software-engineering",
          "name": "AI for Software Engineering",
          "deps": [
            "ai-api-design",
            "model-deployment-multimodal",
            "observability-ai-systems"
          ]
        },
        {
          "id": "ai-data-bi",
          "name": "AI in Data Analysis & BI",
          "deps": [
            "ai-evaluation-benchmarking",
            "ai-knowledge-management"
          ]
        }
      ]
    },
    {
      "id": "foundations-prompting",
      "title": "Foundations: Prompting & Interaction",
      "items": [
        {
          "id": "ai-structured-output-prompts",
          "name": "Structured Output Prompting",
          "deps": []
        },
        {
          "id": "prompt-engineering-patterns",
          "name": "Prompt Engineering Patterns",
          "deps": [
            "ai-structured-output-prompts"
          ]
        },
        {
          "id": "persona-role-prompting",
          "name": "Persona & Role Prompting",
          "deps": [
            "prompt-engineering-patterns"
          ]
        },
        {
          "id": "knowledge-grounded-prompting",
          "name": "Knowledge-Grounded Prompting",
          "deps": [
            "prompt-engineering-patterns",
            "rag-architecture"
          ]
        }
      ]
    },
    {
      "id": "architectures-platforms",
      "title": "Core Architectures & Platforms",
      "items": [
        {
          "id": "rag-architecture",
          "name": "RAG Architecture",
          "deps": [
            "ai-api-design"
          ]
        },
        {
          "id": "agent-architecture",
          "name": "AI Agent Architecture",
          "deps": [
            "ai-api-design",
            "prompt-engineering-patterns"
          ]
        },
        {
          "id": "ai-api-design",
          "name": "AI API Design",
          "deps": [
            "ai-structured-output-prompts"
          ]
        },
        {
          "id": "ai-workflow-orchestration",
          "name": "AI Workflow Orchestration",
          "deps": [
            "ai-api-design",
            "observability-ai-systems"
          ]
        },
        {
          "id": "model-deployment-multimodal",
          "name": "Model Deployment (Multi-Modal)",
          "deps": [
            "model-training-finetuning",
            "observability-ai-systems"
          ]
        },
        {
          "id": "observability-ai-systems",
          "name": "Observability for AI Systems",
          "deps": [
            "ai-evaluation-benchmarking"
          ]
        }
      ]
    },
    {
      "id": "safety-governance-training",
      "title": "Safety, Governance & Training",
      "items": [
        {
          "id": "ai-evaluation-benchmarking",
          "name": "AI Evaluation & Benchmarking",
          "deps": [
            "ai-workflow-orchestration"
          ]
        },
        {
          "id": "ai-safety-guardrails",
          "name": "AI Safety & Guardrails",
          "deps": [
            "ai-governance-compliance",
            "ai-evaluation-benchmarking"
          ]
        },
        {
          "id": "ai-governance-compliance",
          "name": "AI Governance & Compliance",
          "deps": []
        },
        {
          "id": "model-training-finetuning",
          "name": "Model Training & Fine-Tuning",
          "deps": [
            "ai-evaluation-benchmarking"
          ]
        }
      ]
    },
    {
      "id": "workflows-collaboration",
      "title": "Workflows, Collaboration & Knowledge",
      "items": [
        {
          "id": "ai-augmented-workflows",
          "name": "AI-Augmented Workflows",
          "deps": [
            "ai-workflow-orchestration",
            "agent-architecture"
          ]
        },
        {
          "id": "human-in-the-loop-review",
          "name": "Human-in-the-Loop Review Systems",
          "deps": [
            "ai-augmented-workflows",
            "ai-safety-guardrails"
          ]
        },
        {
          "id": "ai-knowledge-management",
          "name": "AI for Knowledge Management",
          "deps": [
            "rag-architecture",
            "knowledge-grounded-prompting"
          ]
        },
        {
          "id": "ai-customer-support",
          "name": "AI for Customer Support Automation",
          "deps": [
            "ai-knowledge-management",
            "ai-augmented-workflows"
          ]
        }
      ]
    }
  ]
}

,
{
"id": "ai-structured-output-prompts",
"title": "AI Structured Output Prompting",
"abstract": "This map covers how to prompt AI systems so they reliably emit machine-parseable, constrained JSON (or similar structures) suitable for downstream automation. It spans from high-level goals around deterministic, integration-friendly responses down through concrete prompt contracts, schema and typing rules, formatting and size constraints, and the validation and tooling components that enforce the contract and catch errors.",
"categories": [
{
"id": "interaction-goals",
"title": "User Interaction Goals",
"items": [
{
"id": "structured-output-goal",
"name": "Structured output goal",
"deps": [
"format-rules-block",
"schema-definition-block",
"model:ai-api-design",
"ai-api-design:response-schema"
]
},
{
"id": "integration-safety-goal",
"name": "Integration safety goal",
"deps": [
"missing-data-policy",
"error-handling-strategy"
]
},
{
"id": "deterministic-behavior-goal",
"name": "Deterministic behavior goal",
"deps": [
"model-configuration",
"testing-iteration-process"
]
}
]
},
{
"id": "prompt-contract",
"title": "Prompt Output Contract",
"items": [
{
"id": "schema-definition-block",
"name": "Schema definition block",
"deps": [
"field-type-spec",
"required-optional-spec",
"enum-spec"
]
},
{
"id": "format-rules-block",
"name": "Format rules block",
"deps": [
"allowed-keys-rules",
"size-complexity-limits"
]
},
{
"id": "error-handling-strategy",
"name": "Error & partial results strategy",
"deps": [
"error-object-design"
]
},
{
"id": "missing-data-policy",
"name": "Missing data policy",
"deps": []
}
]
},
{
"id": "schema-rules",
"title": "Schema & Field Rules",
"items": [
{
"id": "field-type-spec",
"name": "Field type specification",
"deps": []
},
{
"id": "required-optional-spec",
"name": "Required vs optional specification",
"deps": []
},
{
"id": "enum-spec",
"name": "Enum value specification",
"deps": []
},
{
"id": "standardized-formats-rules",
"name": "Standardized formats rules",
"deps": []
},
{
"id": "size-complexity-limits",
"name": "Size & complexity limits",
"deps": []
},
{
"id": "allowed-keys-rules",
"name": "Allowed keys rules",
"deps": []
},
{
"id": "error-object-design",
"name": "Error object design",
"deps": []
}
]
},
{
"id": "execution-setup",
"title": "Execution Setup & Process",
"items": [
{
"id": "model-configuration",
"name": "Model configuration (temperature, etc.)",
"deps": []
},
{
"id": "validation-plan",
"name": "Validation plan",
"deps": [
"json-parser",
"schema-validator"
]
},
{
"id": "testing-iteration-process",
"name": "Testing & iteration process",
"deps": [
"edge-case-test-cases"
]
},
{
"id": "tooling-integration",
"name": "Tooling integration",
"deps": [
"json-parser",
"schema-validator"
]
}
]
},
{
"id": "tooling-components",
"title": "Tooling & Infrastructure Components",
"items": [
{
"id": "json-parser",
"name": "JSON parser",
"deps": []
},
{
"id": "schema-validator",
"name": "Schema validator",
"deps": []
},
{
"id": "edge-case-test-cases",
"name": "Edge-case test cases",
"deps": []
},
{
"id": "logging-and-metrics",
"name": "Logging & metrics",
"deps": []
}
]
}
]
},
{
"id": "prompt-engineering-patterns",
"title": "Prompt Engineering Patterns",
"abstract": "Covers the landscape of prompting techniques—from high-level interaction strategies to concrete pattern components that enable reliable reasoning, decomposition, and controllable outputs.",
"categories": [
{
"id": "user-facing-strategies",
"title": "User-Facing Strategies",
"items": [
{
"id": "explicit-instructions",
"name": "Explicit Instructions",
"deps": [
"format-patterns",
"task-decomposition"
]
},
{
"id": "few-shot-guidance",
"name": "Few-shot Guidance",
"deps": [
"example-selection"
]
},
{
"id": "self-critique-invocation",
"name": "Self-Critique Invocation",
"deps": [
"reflection-pattern"
]
}
]
},
{
"id": "reasoning-patterns",
"title": "Reasoning Patterns",
"items": [
{
"id": "chain-of-thought",
"name": "Chain-of-Thought Reasoning",
"deps": [
"reasoning-structure"
]
},
{
"id": "task-decomposition",
"name": "Task Decomposition",
"deps": [
"reasoning-structure"
]
},
{
"id": "reflection-pattern",
"name": "Reflection Pattern",
"deps": [
"reasoning-structure"
]
}
]
},
{
"id": "example-patterns",
"title": "Example & Demonstration Patterns",
"items": [
{
"id": "example-selection",
"name": "Example Selection",
"deps": []
},
{
"id": "contrast-examples",
"name": "Contrastive Examples",
"deps": [
"example-selection"
]
}
]
},
{
"id": "format-control",
"title": "Format & Output Control",
"items": [
{
"id": "format-patterns",
"name": "Format Patterns (JSON, tables)",
"deps": [
"allowed-keys"
]
},
{
"id": "allowed-keys",
"name": "Allowed Keys Constraints",
"deps": []
},
{
"id": "reasoning-structure",
"name": "Reasoning Structure Specification",
"deps": []
}
]
}
]
},
{
"id": "persona-role-prompting",
"title": "Persona & Role Prompting",
"abstract": "This map outlines how AI behavior is shaped through defined roles, constraints, voice, and interaction norms, enabling consistent and purpose-aligned system personas.",
"categories": [
{
"id": "persona-design",
"title": "Persona Design",
"items": [
{
"id": "role-definition",
"name": "Role Definition",
"deps": [
"behavior-constraints"
]
},
{
"id": "voice-style",
"name": "Voice & Style Definition",
"deps": []
},
{
"id": "domain-expertise",
"name": "Domain Expertise Framing",
"deps": []
}
]
},
{
"id": "interaction-norms",
"title": "Interaction Norms",
"items": [
{
"id": "safety-norms",
"name": "Safety & Scope Norms",
"deps": [
"behavior-constraints"
]
},
{
"id": "communication-rules",
"name": "Communication Rules",
"deps": [
"voice-style"
]
}
]
},
{
"id": "behavioral-controls",
"title": "Behavioral Controls",
"items": [
{
"id": "behavior-constraints",
"name": "Behavior Constraints",
"deps": [
"consistency-checks"
]
},
{
"id": "consistency-checks",
"name": "Consistency Checks",
"deps": []
},
{
"id": "escalation-rules",
"name": "Escalation Rules",
"deps": [
"safety-norms"
]
}
]
},
{
"id": "tools-integration",
"title": "Tools & Capability Integration",
"items": [
{
"id": "tool-use-guidance",
"name": "Tool Use Guidance",
"deps": [
"role-definition"
]
},
{
"id": "persona-limitations",
"name": "Persona Limitations",
"deps": [
"safety-norms"
]
}
]
}
]
},
{
"id": "knowledge-grounded-prompting",
"title": "Knowledge-Grounded Prompting",
"abstract": "Covers methods for binding model outputs to external knowledge sources through retrieval, context construction, grounding rules, uncertainty handling, and citation control.",
"categories": [
{
"id": "user-goals",
"title": "User-Facing Goals",
"items": [
{
"id": "accurate-grounded-answers",
"name": "Accurate Grounded Answers",
"deps": [
"retrieval",
"citation-rules"
]
},
{
"id": "context-aware-responses",
"name": "Context-Aware Responses",
"deps": [
"context-construction"
]
}
]
},
{
"id": "retrieval-layer",
"title": "Retrieval Layer",
"items": [
{
"id": "retrieval",
"name": "Retriever",
"deps": [
"document-index",
"model:rag-architecture",
"rag-architecture:vector-store"
]
},
{
"id": "ranking",
"name": "Ranking Module",
"deps": [
"retrieval"
]
},
{
"id": "document-index",
"name": "Document Index",
"deps": []
}
]
},
{
"id": "context-building",
"title": "Context Construction",
"items": [
{
"id": "context-construction",
"name": "Context Construction Engine",
"deps": [
"retrieval",
"compression"
]
},
{
"id": "compression",
"name": "Context Compression",
"deps": []
}
]
},
{
"id": "grounding-rules",
"title": "Grounding & Attribution",
"items": [
{
"id": "citation-rules",
"name": "Citation Rules",
"deps": []
},
{
"id": "uncertainty-handling",
"name": "Uncertainty Handling",
"deps": []
},
{
"id": "hallucination-mitigation",
"name": "Hallucination Mitigation",
"deps": [
"uncertainty-handling"
]
}
]
},
{
"id": "output-integration",
"title": "Output Integration",
"items": [
{
"id": "response-synthesis",
"name": "Response Synthesis",
"deps": [
"context-construction",
"ranking"
]
},
{
"id": "qa-evaluation",
"name": "QA Evaluation Layer",
"deps": [
"hallucination-mitigation"
]
}
]
}
]
},
{
"id": "rag-architecture",
"title": "Retrieval-Augmented Generation (RAG) Architecture",
"abstract": "This map describes how user-facing, knowledge-grounded experiences (Q&A, document chat, semantic search) are enabled by an orchestration layer that coordinates retrieval, context construction, and grounded generation on top of ingestion, indexing, and core infrastructure services.",
"categories": [
{
"id": "rag-user-flows",
"title": "User-Facing RAG Flows",
"items": [
{
"id": "rag-question-answering",
"name": "RAG Question Answering",
"deps": [
"rag-orchestrator",
"retrieval-router"
]
},
{
"id": "rag-document-chat",
"name": "RAG Document Chat",
"deps": [
"rag-orchestrator",
"session-memory"
]
},
{
"id": "rag-semantic-search-ui",
"name": "RAG Semantic Search UI",
"deps": [
"retrieval-router",
"index-service"
]
}
]
},
{
"id": "rag-orchestration-layer",
"title": "RAG Orchestration Layer",
"items": [
{
"id": "rag-orchestrator",
"name": "RAG Orchestrator",
"deps": [
"retrieval-router",
"context-builder",
"grounded-generation"
]
},
{
"id": "retrieval-router",
"name": "Retrieval Router",
"deps": [
"retriever-bm25",
"retriever-embedding"
]
},
{
"id": "context-builder",
"name": "Context Builder",
"deps": [
"chunk-merger",
"context-limits-policy"
]
},
{
"id": "grounded-generation",
"name": "Grounded Generation",
"deps": [
"llm-backend",
"grounding-constraints"
]
}
]
},
{
"id": "rag-retrieval-layer",
"title": "Retrieval Layer",
"items": [
{
"id": "retriever-embedding",
"name": "Embedding Retriever",
"deps": [
"vector-store"
]
},
{
"id": "retriever-bm25",
"name": "BM25 / Keyword Retriever",
"deps": [
"text-index"
]
},
{
"id": "reranker",
"name": "Result Reranker",
"deps": [
"ml-ranking-model"
]
}
]
},
{
"id": "rag-data-indexing",
"title": "Data Prep & Indexing",
"items": [
{
"id": "ingestion-pipeline",
"name": "Ingestion Pipeline",
"deps": [
"source-connectors",
"chunking-strategy"
]
},
{
"id": "chunking-strategy",
"name": "Chunking Strategy",
"deps": []
},
{
"id": "metadata-enrichment",
"name": "Metadata Enrichment",
"deps": [
"ingestion-pipeline"
]
},
{
"id": "text-index",
"name": "Text Index",
"deps": [
"ingestion-pipeline"
]
},
{
"id": "vector-store",
"name": "Vector Store",
"deps": [
"ingestion-pipeline"
]
},
{
"id": "source-connectors",
"name": "Source Connectors",
"deps": []
}
]
},
{
"id": "rag-foundation-services",
"title": "Foundation Services",
"items": [
{
"id": "llm-backend",
"name": "LLM Backend",
"deps": []
},
{
"id": "context-limits-policy",
"name": "Context Limits Policy",
"deps": []
},
{
"id": "grounding-constraints",
"name": "Grounding Constraints",
"deps": []
},
{
"id": "ml-ranking-model",
"name": "ML Ranking Model",
"deps": []
},
{
"id": "session-memory",
"name": "Session Memory",
"deps": [
"vector-store"
]
},
{
"id": "index-service",
"name": "Index Service API",
"deps": [
"text-index",
"vector-store"
]
}
]
}
]
},
{
"id": "agent-architecture",
"title": "AI Agent Architecture",
"abstract": "This map shows how task-oriented AI agents deliver user-facing task execution, supervision, and collaboration by combining planning, policy control, tool use, memory, and runtime infrastructure components.",
"categories": [
{
"id": "agent-user-goals",
"title": "Agent User Goals",
"items": [
{
"id": "task-execution-agent",
"name": "Task Execution Agent",
"deps": [
"planner",
"tool-executor"
]
},
{
"id": "multi-agent-collab",
"name": "Multi-Agent Collaboration",
"deps": [
"agent-router",
"shared-memory"
]
},
{
"id": "supervisor-agent",
"name": "Supervisor Agent",
"deps": [
"monitoring-loop",
"policy-engine"
]
}
]
},
{
"id": "agent-planning-control",
"title": "Planning & Control",
"items": [
{
"id": "planner",
"name": "Planner",
"deps": [
"policy-engine"
]
},
{
"id": "policy-engine",
"name": "Policy Engine",
"deps": []
},
{
"id": "agent-router",
"name": "Agent Router",
"deps": [
"policy-engine"
]
},
{
"id": "monitoring-loop",
"name": "Monitoring Loop",
"deps": [
"telemetry-stream"
]
}
]
},
{
"id": "agent-tool-use",
"title": "Tool Use",
"items": [
{
"id": "tool-executor",
"name": "Tool Executor",
"deps": [
"tool-registry",
"sandbox-runtime"
]
},
{
"id": "tool-registry",
"name": "Tool Registry",
"deps": []
},
{
"id": "sandbox-runtime",
"name": "Sandbox Runtime",
"deps": []
},
{
"id": "error-recovery-logic",
"name": "Error Recovery Logic",
"deps": [
"monitoring-loop"
]
}
]
},
{
"id": "agent-memory-knowledge",
"title": "Memory & Knowledge",
"items": [
{
"id": "ephemeral-memory",
"name": "Ephemeral Memory",
"deps": []
},
{
"id": "long-term-memory",
"name": "Long-Term Memory",
"deps": [
"vector-memory-store"
]
},
{
"id": "shared-memory",
"name": "Shared Memory",
"deps": [
"vector-memory-store"
]
},
{
"id": "vector-memory-store",
"name": "Vector Memory Store",
"deps": []
}
]
},
{
"id": "agent-runtime-infra",
"title": "Runtime & Infrastructure",
"items": [
{
"id": "agent-runtime-api",
"name": "Agent Runtime API",
"deps": [
"sandbox-runtime",
"telemetry-stream"
]
},
{
"id": "telemetry-stream",
"name": "Telemetry Stream",
"deps": []
},
{
"id": "authn-authz-layer",
"name": "AuthN/AuthZ Layer",
"deps": []
},
{
"id": "config-store",
"name": "Configuration Store",
"deps": []
}
]
}
]
},
{
"id": "ai-api-design",
"title": "AI API Design",
"abstract": "This map covers how user-facing AI APIs (chat, tools, batch jobs) are shaped by request and response schemas, error and status models, cross-cutting concerns like auth and rate limits, and platform infrastructure components such as gateways and observability.",
"categories": [
{
"id": "api-products",
"title": "API Products",
"items": [
{
"id": "chat-completions-api",
"name": "Chat Completions API",
"deps": [
"request-schema",
"response-schema",
"rate-limits"
]
},
{
"id": "batch-processing-api",
"name": "Batch Processing API",
"deps": [
"request-schema",
"async-job-model",
"rate-limits"
]
},
{
"id": "tools-functions-api",
"name": "Tools / Functions API",
"deps": [
"tool-schema",
"request-schema",
"response-schema"
]
}
]
},
{
"id": "api-request-modeling",
"title": "Request Modeling",
"items": [
{
"id": "request-schema",
"name": "Request Schema",
"deps": [
"idempotency-rules"
]
},
{
"id": "tool-schema",
"name": "Tool / Function Schema",
"deps": []
},
{
"id": "async-job-model",
"name": "Async Job Model",
"deps": [
"status-field-model"
]
}
]
},
{
"id": "api-response-contracts",
"title": "Response Contracts",
"items": [
{
"id": "response-schema",
"name": "Response Schema",
"deps": [
"error-envelope",
"pagination-model"
]
},
{
"id": "error-envelope",
"name": "Error Envelope",
"deps": []
},
{
"id": "status-field-model",
"name": "Status Field Model",
"deps": []
},
{
"id": "pagination-model",
"name": "Pagination Model",
"deps": []
}
]
},
{
"id": "api-cross-cutting",
"title": "Cross-Cutting Concerns",
"items": [
{
"id": "auth-layer",
"name": "Authentication Layer",
"deps": []
},
{
"id": "rate-limits",
"name": "Rate Limits",
"deps": [
"quota-model"
]
},
{
"id": "quota-model",
"name": "Quota Model",
"deps": []
},
{
"id": "observability-hooks",
"name": "Observability Hooks",
"deps": [
"logging-pipeline",
"metrics-pipeline"
]
},
{
"id": "idempotency-rules",
"name": "Idempotency Rules",
"deps": []
}
]
},
{
"id": "api-platform-infra",
"title": "Platform Infrastructure",
"items": [
{
"id": "gateway",
"name": "API Gateway",
"deps": [
"auth-layer",
"rate-limits"
]
},
{
"id": "logging-pipeline",
"name": "Logging Pipeline",
"deps": []
},
{
"id": "metrics-pipeline",
"name": "Metrics Pipeline",
"deps": []
},
{
"id": "schema-registry",
"name": "Schema Registry",
"deps": []
}
]
}
]
},
{
"id": "ai-workflow-orchestration",
"title": "AI Workflow Orchestration",
"abstract": "This map describes how end-to-end AI workflows deliver user value (content review, enrichment, evaluation) through an orchestration engine, human-in-the-loop steps, reliability patterns, and the underlying infrastructure services that schedule, queue, and observe work.",
"categories": [
{
"id": "orchestration-workflows",
"title": "User-Facing Workflows",
"items": [
{
"id": "content-review-workflow",
"name": "Content Review Workflow",
"deps": [
"orchestration-engine",
"hitl-step",
"policy-check-step",
"model:human-in-the-loop-review",
"human-in-the-loop-review:review-orchestrator"
]
},
{
"id": "data-enrichment-workflow",
"name": "Data Enrichment Workflow",
"deps": [
"orchestration-engine",
"fanout-step"
]
},
{
"id": "evaluation-workflow",
"name": "Evaluation Workflow",
"deps": [
"orchestration-engine",
"metrics-step"
]
}
]
},
{
"id": "orchestration-core",
"title": "Orchestration Engine",
"items": [
{
"id": "orchestration-engine",
"name": "Orchestration Engine",
"deps": [
"workflow-dsl",
"task-runner"
]
},
{
"id": "workflow-dsl",
"name": "Workflow DSL",
"deps": []
},
{
"id": "task-runner",
"name": "Task Runner",
"deps": [
"queue-backend"
]
},
{
"id": "scheduler",
"name": "Scheduler",
"deps": [
"queue-backend"
]
}
]
},
{
"id": "human-in-the-loop",
"title": "Human-in-the-Loop",
"items": [
{
"id": "hitl-step",
"name": "HITL Step",
"deps": [
"review-ui",
"assignment-logic"
]
},
{
"id": "review-ui",
"name": "Reviewer UI",
"deps": []
},
{
"id": "assignment-logic",
"name": "Assignment Logic",
"deps": [
"user-directory"
]
},
{
"id": "user-directory",
"name": "User Directory",
"deps": []
}
]
},
{
"id": "orchestration-reliability",
"title": "Reliability & Observability",
"items": [
{
"id": "retry-policy",
"name": "Retry Policy",
"deps": []
},
{
"id": "circuit-breaker",
"name": "Circuit Breaker",
"deps": []
},
{
"id": "dead-letter-queue",
"name": "Dead Letter Queue",
"deps": [
"queue-backend"
]
},
{
"id": "metrics-step",
"name": "Metrics Step",
"deps": [
"metrics-backend"
]
},
{
"id": "policy-check-step",
"name": "Policy Check Step",
"deps": [
"policy-engine-orchestration"
]
},
{
"id": "policy-engine-orchestration",
"name": "Policy Engine (Orchestration)",
"deps": []
},
{
"id": "fanout-step",
"name": "Fan-out Step",
"deps": [
"task-runner"
]
}
]
},
{
"id": "orchestration-infra",
"title": "Infrastructure",
"items": [
{
"id": "queue-backend",
"name": "Queue Backend",
"deps": []
},
{
"id": "metrics-backend",
"name": "Metrics Backend",
"deps": []
},
{
"id": "secrets-store",
"name": "Secrets Store",
"deps": []
},
{
"id": "deployment-pipeline",
"name": "Deployment Pipeline",
"deps": []
}
]
}
]
},
{
"id": "ai-evaluation-benchmarking",
"title": "AI Evaluation & Benchmarking",
"abstract": "This map outlines how user-visible evaluation outputs—scores, dashboards, reports—are enabled by test suites, metrics, evaluation pipelines, and supporting infrastructure for dataset management, execution, and reproducibility.",
"categories": [
{
"id": "evaluation-user-facing",
"title": "User-Facing Evaluation Outputs",
"items": [
{
"id": "eval-scores-dashboard",
"name": "Evaluation Scores Dashboard",
"deps": [
"eval-engine",
"metrics-library"
]
},
{
"id": "benchmark-reports",
"name": "Benchmark Reports",
"deps": [
"eval-engine",
"report-generator"
]
},
{
"id": "regression-alerts",
"name": "Regression Alerts",
"deps": [
"metrics-store",
"alerting-system",
"model:observability-ai-systems",
"observability-ai-systems:alerting-engine"
]
}
]
},
{
"id": "evaluation-core",
"title": "Evaluation Engine",
"items": [
{
"id": "eval-engine",
"name": "Evaluation Engine",
"deps": [
"test-suite",
"metrics-library",
"scoring-policy"
]
},
{
"id": "scoring-policy",
"name": "Scoring Policy",
"deps": []
},
{
"id": "report-generator",
"name": "Report Generator",
"deps": []
}
]
},
{
"id": "eval-test-suites",
"title": "Test Suites & Datasets",
"items": [
{
"id": "test-suite",
"name": "Test Suite",
"deps": [
"dataset-registry"
]
},
{
"id": "dataset-registry",
"name": "Dataset Registry",
"deps": []
},
{
"id": "synthetic-data-generator",
"name": "Synthetic Data Generator",
"deps": []
}
]
},
{
"id": "evaluation-metrics",
"title": "Metrics & Observability",
"items": [
{
"id": "metrics-library",
"name": "Metrics Library",
"deps": []
},
{
"id": "metrics-store",
"name": "Metrics Store",
"deps": []
},
{
"id": "alerting-system",
"name": "Alerting System",
"deps": [
"metrics-store"
]
}
]
},
{
"id": "eval-infra",
"title": "Infrastructure",
"items": [
{
"id": "eval-runner",
"name": "Evaluation Runner",
"deps": []
},
{
"id": "artifact-storage",
"name": "Artifact Storage",
"deps": []
},
{
"id": "compute-cluster",
"name": "Compute Cluster",
"deps": []
}
]
}
]
},
{
"id": "ai-safety-guardrails",
"title": "AI Safety & Guardrails",
"abstract": "This map describes how safe user-facing interactions are produced: from content filtering and safety routing to policy engines, red-teaming pipelines, and foundational infrastructure that enforces constraints and logs risky events.",
"categories": [
{
"id": "safety-user-facing",
"title": "User-Facing Safety Layers",
"items": [
{
"id": "content-filter",
"name": "Content Filter",
"deps": [
"policy-engine-safety",
"classifier-models"
]
},
{
"id": "safety-router",
"name": "Safety Router",
"deps": [
"policy-engine-safety"
]
},
{
"id": "safe-completions",
"name": "Safe Completions Generator",
"deps": [
"llm-backend-safety",
"content-filter",
"model:ai-governance-compliance",
"ai-governance-compliance:policy-compliance-engine"
]
}
]
},
{
"id": "safety-governance",
"title": "Safety Policies & Governance",
"items": [
{
"id": "policy-engine-safety",
"name": "Policy Engine (Safety)",
"deps": [
"policy-ruleset"
]
},
{
"id": "policy-ruleset",
"name": "Policy Ruleset",
"deps": []
},
{
"id": "audit-logging",
"name": "Audit Logging",
"deps": []
}
]
},
{
"id": "safety-models",
"title": "Classifier Models & Evaluators",
"items": [
{
"id": "classifier-models",
"name": "Safety Classifier Models",
"deps": [
"training-data-safety"
]
},
{
"id": "risk-scorer",
"name": "Risk Scoring Module",
"deps": [
"classifier-models"
]
},
{
"id": "training-data-safety",
"name": "Safety Training Data",
"deps": []
}
]
},
{
"id": "red-teaming",
"title": "Red-Teaming & Evaluation",
"items": [
{
"id": "red-team-scenarios",
"name": "Red Team Scenarios",
"deps": [
"risk-categories"
]
},
{
"id": "automated-attacks",
"name": "Automated Attack Generator",
"deps": []
},
{
"id": "risk-categories",
"name": "Risk Categories",
"deps": []
}
]
},
{
"id": "safety-infra",
"title": "Safety Infrastructure",
"items": [
{
"id": "safety-metrics-store",
"name": "Safety Metrics Store",
"deps": []
},
{
"id": "event-collector",
"name": "Event Collector",
"deps": []
},
{
"id": "llm-backend-safety",
"name": "LLM Backend (Safety-Aligned)",
"deps": []
}
]
}
]
},
{
"id": "ai-governance-compliance",
"title": "AI Governance & Compliance",
"abstract": "This map shows how compliant, auditable AI systems are delivered by linking user-facing governance features to policy frameworks, auditability components, data governance systems, and foundational compliance infrastructure.",
"categories": [
{
"id": "gov-user-facing",
"title": "User-Facing Governance Features",
"items": [
{
"id": "model-card-ui",
"name": "Model Card UI",
"deps": [
"governance-registry",
"risk-assessment"
]
},
{
"id": "compliance-dashboard",
"name": "Compliance Dashboard",
"deps": [
"audit-log-store",
"policy-compliance-engine"
]
},
{
"id": "consent-management-ui",
"name": "Consent Management UI",
"deps": [
"consent-service"
]
}
]
},
{
"id": "policy-governance",
"title": "Policy & Governance Frameworks",
"items": [
{
"id": "policy-compliance-engine",
"name": "Policy Compliance Engine",
"deps": [
"policy-library"
]
},
{
"id": "policy-library",
"name": "Policy Library",
"deps": []
},
{
"id": "risk-assessment",
"name": "Risk Assessment Models",
"deps": []
}
]
},
{
"id": "auditability",
"title": "Auditability & Traceability",
"items": [
{
"id": "audit-log-store",
"name": "Audit Log Store",
"deps": []
},
{
"id": "provenance-tracker",
"name": "Provenance Tracker",
"deps": [
"artifact-store-governance"
]
},
{
"id": "explainability-module",
"name": "Explainability Module",
"deps": []
}
]
},
{
"id": "data-governance",
"title": "Data Governance",
"items": [
{
"id": "consent-service",
"name": "Consent Service",
"deps": [
"consent-records"
]
},
{
"id": "data-retention-service",
"name": "Data Retention Service",
"deps": []
},
{
"id": "consent-records",
"name": "Consent Records Store",
"deps": []
}
]
},
{
"id": "gov-infra",
"title": "Governance Infrastructure",
"items": [
{
"id": "governance-registry",
"name": "Governance Registry",
"deps": []
},
{
"id": "artifact-store-governance",
"name": "Artifact Store (Governance)",
"deps": []
},
{
"id": "identity-service",
"name": "Identity Service",
"deps": []
}
]
}
]
},
{
"id": "model-training-finetuning",
"title": "Model Training & Fine-Tuning",
"abstract": "This map shows how user-visible outcomes like production-ready models and reproducible experiments depend on data pipelines, model-building workflows, training operations, and underlying training infrastructure.",
"categories": [
{
"id": "training-goals",
"title": "User-Facing Training Goals",
"items": [
{
"id": "production-model-release",
"name": "Production Model Release",
"deps": [
"finetuning-setup",
"evaluation-loop",
"checkpoint-management"
]
},
{
"id": "experiment-reporting",
"name": "Experiment Reporting",
"deps": [
"experiment-tracking",
"evaluation-loop"
]
},
{
"id": "reusable-datasets",
"name": "Reusable Training Datasets",
"deps": [
"data-versioning",
"data-cleaning"
]
}
]
},
{
"id": "data-pipeline",
"title": "Data Pipeline & Preparation",
"items": [
{
"id": "raw-data-ingestion",
"name": "Raw Data Ingestion",
"deps": []
},
{
"id": "data-cleaning",
"name": "Data Cleaning & Normalization",
"deps": [
"raw-data-ingestion"
]
},
{
"id": "labeling-workflow",
"name": "Labeling Workflow",
"deps": [
"raw-data-ingestion"
]
},
{
"id": "feature-engineering",
"name": "Feature Engineering",
"deps": [
"data-cleaning"
]
},
{
"id": "data-versioning",
"name": "Data Versioning",
"deps": [
"training-storage"
]
}
]
},
{
"id": "model-building",
"title": "Model Design & Setup",
"items": [
{
"id": "model-architecture-design",
"name": "Model Architecture Design",
"deps": []
},
{
"id": "pretraining-setup",
"name": "Pretraining Setup",
"deps": [
"model-architecture-design",
"compute-cluster-training"
]
},
{
"id": "finetuning-setup",
"name": "Fine-Tuning Setup",
"deps": [
"pretraining-setup",
"labeling-workflow"
]
},
{
"id": "hyperparam-search",
"name": "Hyperparameter Search",
"deps": [
"training-orchestrator",
"compute-cluster-training"
]
}
]
},
{
"id": "training-operations",
"title": "Training Operations",
"items": [
{
"id": "training-orchestrator",
"name": "Training Orchestrator",
"deps": [
"compute-cluster-training",
"secrets-manager-training"
]
},
{
"id": "experiment-tracking",
"name": "Experiment Tracking",
"deps": [
"artifact-store-training"
]
},
{
"id": "checkpoint-management",
"name": "Checkpoint Management",
"deps": [
"artifact-store-training"
]
},
{
"id": "evaluation-loop",
"name": "Evaluation Loop",
"deps": [
"metrics-backend-training",
"experiment-tracking"
]
}
]
},
{
"id": "training-infrastructure",
"title": "Training Infrastructure",
"items": [
{
"id": "compute-cluster-training",
"name": "Training Compute Cluster",
"deps": []
},
{
"id": "artifact-store-training",
"name": "Training Artifact Store",
"deps": []
},
{
"id": "metrics-backend-training",
"name": "Training Metrics Backend",
"deps": []
},
{
"id": "training-storage",
"name": "Training Data Storage",
"deps": []
},
{
"id": "secrets-manager-training",
"name": "Training Secrets Manager",
"deps": []
}
]
}
]
},
{
"id": "model-deployment-multimodal",
"title": "Model Deployment (Multi-Modal)",
"abstract": "This map covers how user-facing inference surfaces (APIs, batch jobs, streaming, multimodal content endpoints) are powered by serving layers, deployment operations, runtime platforms, and deployment infrastructure.",
"categories": [
{
"id": "deployment-experiences",
"title": "User-Facing Deployment Experiences",
"items": [
{
"id": "online-inference-api",
"name": "Online Inference API",
"deps": [
"model-serving-service",
"routing-layer"
]
},
{
"id": "batch-inference-jobs",
"name": "Batch Inference Jobs",
"deps": [
"batch-scheduler",
"model-serving-service"
]
},
{
"id": "realtime-stream-processing",
"name": "Real-Time Stream Processing",
"deps": [
"stream-processor",
"routing-layer"
]
},
{
"id": "multimodal-content-api",
"name": "Multimodal Content API",
"deps": [
"model-serving-service",
"feature-store-online"
]
}
]
},
{
"id": "serving-layer",
"title": "Serving Layer",
"items": [
{
"id": "model-serving-service",
"name": "Model Serving Service",
"deps": [
"runtime-platform-core",
"artifact-registry",
"secrets-store-deploy"
]
},
{
"id": "routing-layer",
"name": "Routing Layer",
"deps": [
"service-mesh"
]
},
{
"id": "feature-store-online",
"name": "Online Feature Store",
"deps": [
"online-features-store-backend"
]
},
{
"id": "canary-deployment-engine",
"name": "Canary Deployment Engine",
"deps": [
"release-pipeline",
"service-mesh"
]
},
{
"id": "batch-scheduler",
"name": "Batch Scheduler",
"deps": [
"runtime-platform-core"
]
}
]
},
{
"id": "deployment-operations",
"title": "Deployment Operations",
"items": [
{
"id": "release-pipeline",
"name": "Release Pipeline",
"deps": [
"artifact-registry",
"config-service"
]
},
{
"id": "rollout-strategy",
"name": "Rollout Strategy",
"deps": [
"canary-deployment-engine",
"traffic-shadowing"
]
},
{
"id": "incident-response-playbook",
"name": "Incident Response Playbook",
"deps": [
"alerting-rules"
]
},
{
"id": "autoscaling-policy",
"name": "Autoscaling Policy",
"deps": [
"metrics-backend-deploy"
]
},
{
"id": "traffic-shadowing",
"name": "Traffic Shadowing",
"deps": [
"routing-layer"
]
}
]
},
{
"id": "runtime-platform",
"title": "Runtime Platform",
"items": [
{
"id": "runtime-platform-core",
"name": "Runtime Platform Core",
"deps": [
"container-orchestrator",
"service-mesh",
"observability-agent"
]
},
{
"id": "container-orchestrator",
"name": "Container Orchestrator",
"deps": [
"compute-cluster-deploy"
]
},
{
"id": "service-mesh",
"name": "Service Mesh",
"deps": [
"compute-cluster-deploy"
]
},
{
"id": "observability-agent",
"name": "Observability Agent",
"deps": [
"logging-backend",
"metrics-backend-deploy"
]
},
{
"id": "config-service",
"name": "Config Service",
"deps": [
"config-store-deploy"
]
},
{
"id": "online-features-store-backend",
"name": "Online Features Store Backend",
"deps": [
"compute-cluster-deploy"
]
},
{
"id": "stream-processor",
"name": "Stream Processor",
"deps": [
"compute-cluster-deploy"
]
}
]
},
{
"id": "deployment-infrastructure",
"title": "Deployment Infrastructure",
"items": [
{
"id": "compute-cluster-deploy",
"name": "Deployment Compute Cluster",
"deps": []
},
{
"id": "logging-backend",
"name": "Logging Backend",
"deps": []
},
{
"id": "metrics-backend-deploy",
"name": "Deployment Metrics Backend",
"deps": []
},
{
"id": "secrets-store-deploy",
"name": "Secrets Store",
"deps": []
},
{
"id": "artifact-registry",
"name": "Artifact Registry",
"deps": []
},
{
"id": "config-store-deploy",
"name": "Config Store",
"deps": []
},
{
"id": "alerting-rules",
"name": "Alerting Rules",
"deps": [
"metrics-backend-deploy"
]
}
]
}
]
},
{
"id": "observability-ai-systems",
"title": "Observability for AI Systems",
"abstract": "This map illustrates how observability surfaces like reliability dashboards and incident runbooks are built on telemetry collection, analytics, alerting governance, and observability infrastructure.",
"categories": [
{
"id": "observability-goals",
"title": "User-Facing Observability Goals",
"items": [
{
"id": "reliability-dashboard",
"name": "Reliability Dashboard",
"deps": [
"metrics-service",
"traces-service"
]
},
{
"id": "quality-dashboard",
"name": "Quality & Evaluation Dashboard",
"deps": [
"eval-metrics-pipeline",
"logging-service"
]
},
{
"id": "operations-runbooks",
"name": "Operations Runbooks",
"deps": [
"incident-tracking",
"alerting-engine"
]
}
]
},
{
"id": "telemetry-collection",
"title": "Telemetry Collection",
"items": [
{
"id": "logging-service",
"name": "Logging Service",
"deps": [
"log-collectors",
"log-schema"
]
},
{
"id": "metrics-service",
"name": "Metrics Service",
"deps": [
"metrics-collectors"
]
},
{
"id": "traces-service",
"name": "Traces Service",
"deps": [
"trace-collectors"
]
},
{
"id": "user-feedback-stream",
"name": "User Feedback Stream",
"deps": [
"event-bus"
]
},
{
"id": "log-collectors",
"name": "Log Collectors",
"deps": []
},
{
"id": "metrics-collectors",
"name": "Metrics Collectors",
"deps": []
},
{
"id": "trace-collectors",
"name": "Trace Collectors",
"deps": []
}
]
},
{
"id": "analysis-aggregation",
"title": "Analysis & Aggregation",
"items": [
{
"id": "metrics-aggregation",
"name": "Metrics Aggregation",
"deps": [
"metrics-service"
]
},
{
"id": "log-analytics",
"name": "Log Analytics",
"deps": [
"logging-service"
]
},
{
"id": "trace-analytics",
"name": "Trace Analytics",
"deps": [
"traces-service"
]
},
{
"id": "eval-metrics-pipeline",
"name": "Evaluation Metrics Pipeline",
"deps": [
"metrics-service",
"event-bus"
]
},
{
"id": "anomaly-detection",
"name": "Anomaly Detection",
"deps": [
"metrics-aggregation"
]
}
]
},
{
"id": "alerting-governance",
"title": "Alerting & Governance",
"items": [
{
"id": "alerting-engine",
"name": "Alerting Engine",
"deps": [
"metrics-aggregation",
"anomaly-detection"
]
},
{
"id": "sloa-policy-store",
"name": "SLO/SLA Policy Store",
"deps": []
},
{
"id": "incident-tracking",
"name": "Incident Tracking",
"deps": [
"ticketing-system"
]
},
{
"id": "oncall-rotation",
"name": "On-Call Rotation Management",
"deps": [
"identity-directory"
]
}
]
},
{
"id": "observability-infrastructure",
"title": "Observability Infrastructure",
"items": [
{
"id": "event-bus",
"name": "Event Bus",
"deps": []
},
{
"id": "storage-backend-observability",
"name": "Observability Storage Backend",
"deps": []
},
{
"id": "dashboarding-platform",
"name": "Dashboarding Platform",
"deps": [
"storage-backend-observability"
]
},
{
"id": "ticketing-system",
"name": "Ticketing System",
"deps": []
},
{
"id": "identity-directory",
"name": "Identity Directory",
"deps": []
}
]
}
]
},
{
"id": "ai-augmented-workflows",
"title": "AI-Augmented Workflows",
"abstract": "This map describes how AI-augmented workflows deliver user-visible value—assistive content creation, decision support, and automation—through well-defined workflow designs, collaboration patterns, AI capability modules, and the workflow infrastructure that runs them.",
"categories": [
{
"id": "augmented-user-workflows",
"title": "AI-Augmented User Workflows",
"items": [
{
"id": "content-creation-assist",
"name": "Content Creation Assist",
"deps": [
"suggestion-engine",
"summarization-module",
"workflow-mapping"
]
},
{
"id": "decision-support-flows",
"name": "Decision Support Flows",
"deps": [
"suggestion-engine",
"classification-module",
"risk-assessment-workflows"
]
},
{
"id": "automation-playbooks",
"name": "Automation Playbooks",
"deps": [
"workflow-engine",
"task-queue",
"handoff-patterns"
]
}
]
},
{
"id": "workflow-design",
"title": "Workflow Design & Mapping",
"items": [
{
"id": "workflow-mapping",
"name": "Workflow Mapping",
"deps": [
"workflow-engine"
]
},
{
"id": "task-boundaries",
"name": "Task Boundaries & Roles",
"deps": [
"workflow-mapping",
"risk-assessment-workflows"
]
},
{
"id": "risk-assessment-workflows",
"name": "Workflow Risk Assessment",
"deps": [
"classification-module"
]
}
]
},
{
"id": "collaboration-patterns",
"title": "Collaboration & Handoff Patterns",
"items": [
{
"id": "handoff-patterns",
"name": "Human–AI Handoff Patterns",
"deps": [
"workflow-mapping"
]
},
{
"id": "review-approval-patterns",
"name": "Review & Approval Patterns",
"deps": [
"handoff-patterns",
"notification-rules"
]
},
{
"id": "notification-rules",
"name": "Notification Rules",
"deps": [
"workflow-engine"
]
}
]
},
{
"id": "ai-capabilities",
"title": "AI Capabilities Layer",
"items": [
{
"id": "suggestion-engine",
"name": "Suggestion Engine",
"deps": []
},
{
"id": "summarization-module",
"name": "Summarization Module",
"deps": []
},
{
"id": "classification-module",
"name": "Classification Module",
"deps": []
}
]
},
{
"id": "workflow-platform-infra",
"title": "Workflow Platform & Infrastructure",
"items": [
{
"id": "workflow-engine",
"name": "Workflow Engine",
"deps": [
"task-queue",
"identity-directory-workflows"
]
},
{
"id": "task-queue",
"name": "Task Queue",
"deps": []
},
{
"id": "identity-directory-workflows",
"name": "Identity Directory (Workflows)",
"deps": []
},
{
"id": "audit-log-workflows",
"name": "Workflow Audit Log",
"deps": [
"workflow-engine"
]
}
]
}
]
},
{
"id": "human-in-the-loop-review",
"title": "Human-in-the-Loop Review Systems",
"abstract": "This map covers how human-in-the-loop review systems provide visible controls—review consoles, escalations, and feedback loops—by combining policy frameworks, review orchestration, scoring and prioritization, and shared infrastructure for storage, identity, and analytics.",
"categories": [
{
"id": "hitl-user-experiences",
"title": "User-Facing HITL Experiences",
"items": [
{
"id": "reviewer-console",
"name": "Reviewer Console",
"deps": [
"review-orchestrator",
"review-policies"
]
},
{
"id": "escalation-flows",
"name": "Escalation Flows",
"deps": [
"severity-levels",
"review-orchestrator"
]
},
{
"id": "quality-feedback-loop",
"name": "Quality Feedback Loop",
"deps": [
"analytics-warehouse",
"review-policies",
"model:ai-augmented-workflows",
"ai-augmented-workflows:automation-playbooks"
]
}
]
},
{
"id": "review-policy-design",
"title": "Review Policy Design",
"items": [
{
"id": "review-policies",
"name": "Review Policies",
"deps": [
"severity-levels"
]
},
{
"id": "sampling-strategy",
"name": "Sampling Strategy",
"deps": [
"prefilter-scoring"
]
},
{
"id": "severity-levels",
"name": "Severity Levels",
"deps": []
}
]
},
{
"id": "review-orchestration",
"title": "Review Orchestration",
"items": [
{
"id": "review-orchestrator",
"name": "Review Orchestrator",
"deps": [
"assignment-engine",
"priority-queue",
"case-store"
]
},
{
"id": "assignment-engine",
"name": "Assignment Engine",
"deps": [
"reviewer-directory",
"sla-tracking"
]
},
{
"id": "sla-tracking",
"name": "SLA Tracking",
"deps": [
"case-store"
]
}
]
},
{
"id": "scoring-and-signals",
"title": "Scoring & Signals",
"items": [
{
"id": "prefilter-scoring",
"name": "Pre-Filter Scoring",
"deps": []
},
{
"id": "uncertainty-estimator",
"name": "Uncertainty Estimator",
"deps": []
},
{
"id": "priority-queue",
"name": "Priority Queue",
"deps": [
"prefilter-scoring",
"uncertainty-estimator"
]
}
]
},
{
"id": "hitl-platform-infra",
"title": "HITL Platform & Infrastructure",
"items": [
{
"id": "reviewer-directory",
"name": "Reviewer Directory",
"deps": []
},
{
"id": "case-store",
"name": "Case Store",
"deps": []
},
{
"id": "notification-service-hitl",
"name": "Notification Service",
"deps": []
},
{
"id": "analytics-warehouse",
"name": "Analytics Warehouse",
"deps": [
"case-store"
]
}
]
}
]
},
{
"id": "ai-product-design",
"title": "AI for Product Design",
"abstract": "This map covers how AI enhances product design workflows—from ideation and prototyping to evaluation—enabled by generative modules, research tools, validation layers, and supporting infrastructure.",
"categories": [
{
"id": "design-user-flows",
"title": "User-Facing Design Flows",
"items": [
{
"id": "ideation-assistant",
"name": "Ideation Assistant",
"deps": [
"generative-concepts",
"design-research-engine"
]
},
{
"id": "prototype-generator",
"name": "Prototype Generator",
"deps": [
"generative-layout-engine",
"asset-library"
]
},
{
"id": "design-evaluator",
"name": "Design Evaluator",
"deps": [
"testing-modules",
"metrics-design"
]
}
]
},
{
"id": "generative-design",
"title": "Generative Design Engines",
"items": [
{
"id": "generative-concepts",
"name": "Concept Generation Model",
"deps": []
},
{
"id": "generative-layout-engine",
"name": "Layout / Variant Generator",
"deps": [
"asset-library"
]
},
{
"id": "design-optimizer",
"name": "Design Optimizer",
"deps": [
"metrics-design"
]
}
]
},
{
"id": "research-validation",
"title": "Research & Validation",
"items": [
{
"id": "design-research-engine",
"name": "Design Research Engine",
"deps": [
"knowledge-base-design"
]
},
{
"id": "testing-modules",
"name": "Usability & Performance Test Modules",
"deps": []
},
{
"id": "metrics-design",
"name": "Design Metrics Library",
"deps": []
},
{
"id": "knowledge-base-design",
"name": "Design Knowledge Base",
"deps": []
}
]
},
{
"id": "design-infra",
"title": "Design Infrastructure",
"items": [
{
"id": "asset-library",
"name": "Design Asset Library",
"deps": []
},
{
"id": "collaboration-platform",
"name": "Collaboration Platform",
"deps": []
},
{
"id": "version-control-design",
"name": "Design Version Control",
"deps": []
}
]
}
]
},
{
"id": "ai-software-engineering",
"title": "AI for Software Engineering",
"abstract": "This map illustrates how AI accelerates software engineering through code generation, static analysis, automated testing, and delivery workflows supported by runtime tooling and infrastructure.",
"categories": [
{
"id": "developer-facing-tools",
"title": "Developer-Facing Tools",
"items": [
{
"id": "codegen-assistant",
"name": "Code Generation Assistant",
"deps": [
"code-model",
"context-expander"
]
},
{
"id": "review-assistant",
"name": "Code Review Assistant",
"deps": [
"lint-engine",
"analysis-model"
]
},
{
"id": "debugging-assistant",
"name": "Debugging Assistant",
"deps": [
"execution-traces",
"analysis-model"
]
}
]
},
{
"id": "static-dynamic-analysis",
"title": "Static & Dynamic Analysis",
"items": [
{
"id": "lint-engine",
"name": "Lint Engine",
"deps": []
},
{
"id": "analysis-model",
"name": "Analysis Model",
"deps": [
"code-model"
]
},
{
"id": "test-case-generator",
"name": "AI Test Case Generator",
"deps": [
"analysis-model"
]
},
{
"id": "execution-traces",
"name": "Execution Traces Collector",
"deps": []
}
]
},
{
"id": "software-delivery",
"title": "Build & Delivery Workflows",
"items": [
{
"id": "ci-pipeline-ai",
"name": "AI-Augmented CI Pipeline",
"deps": [
"test-case-generator",
"build-system"
]
},
{
"id": "cd-pipeline-ai",
"name": "AI-Assisted CD Pipeline",
"deps": [
"quality-gates",
"deployment-engine"
]
},
{
"id": "quality-gates",
"name": "Quality Gates",
"deps": [
"lint-engine",
"metrics-se"
]
},
{
"id": "build-system",
"name": "Build System",
"deps": []
}
]
},
{
"id": "se-runtime-infra",
"title": "Runtime & Infrastructure",
"items": [
{
"id": "deployment-engine",
"name": "Deployment Engine",
"deps": [
"artifact-repo-se"
]
},
{
"id": "artifact-repo-se",
"name": "Artifact Repository",
"deps": []
},
{
"id": "metrics-se",
"name": "Engineering Metrics Backend",
"deps": []
}
]
}
]
},
{
"id": "ai-customer-support",
"title": "AI for Customer Support Automation",
"abstract": "This map explains how AI-powered support systems deliver user-visible automated responses, escalations, and insights through orchestrated bots, classification modules, routing logic, and enterprise support infrastructure.",
"categories": [
{
"id": "support-experiences",
"title": "User-Facing Support Experiences",
"items": [
{
"id": "support-chatbot",
"name": "Support Chatbot",
"deps": [
"intent-classifier",
"response-generator",
"model:ai-knowledge-management",
"ai-knowledge-management:knowledge-search"
]
},
{
"id": "auto-escalation",
"name": "Auto-Escalation Engine",
"deps": [
"triage-classifier",
"ticket-system"
]
},
{
"id": "support-insights-dashboard",
"name": "Support Insights Dashboard",
"deps": [
"support-analytics",
"event-stream-support"
]
}
]
},
{
"id": "support-ai-layer",
"title": "AI Layer",
"items": [
{
"id": "intent-classifier",
"name": "Intent Classifier",
"deps": [
"nlp-model"
]
},
{
"id": "response-generator",
"name": "Response Generator",
"deps": [
"nlp-model"
]
},
{
"id": "triage-classifier",
"name": "Triage Classifier",
"deps": [
"nlp-model"
]
},
{
"id": "nlp-model",
"name": "NLP Model",
"deps": []
}
]
},
{
"id": "support-routing",
"title": "Routing & Case Management",
"items": [
{
"id": "routing-logic",
"name": "Routing Logic",
"deps": [
"intent-classifier",
"triage-classifier"
]
},
{
"id": "ticket-system",
"name": "Ticketing System",
"deps": []
},
{
"id": "case-prioritizer",
"name": "Case Prioritizer",
"deps": [
"triage-classifier"
]
}
]
},
{
"id": "support-infra",
"title": "Support Infrastructure",
"items": [
{
"id": "support-analytics",
"name": "Support Analytics Warehouse",
"deps": [
"ticket-system"
]
},
{
"id": "event-stream-support",
"name": "Support Event Stream",
"deps": []
},
{
"id": "identity-service-support",
"name": "Identity Service",
"deps": []
}
]
}
]
},
{
"id": "ai-knowledge-management",
"title": "AI for Knowledge Management",
"abstract": "This map details how AI enhances knowledge management by enabling retrieval, summarization, enrichment, semantic linking, and organizational knowledge infrastructure.",
"categories": [
{
"id": "km-experiences",
"title": "Knowledge Management Experiences",
"items": [
{
"id": "knowledge-search",
"name": "Knowledge Search",
"deps": [
"km-retriever",
"km-index"
]
},
{
"id": "auto-summarization-km",
"name": "Automated Summarization",
"deps": [
"km-summarizer"
]
},
{
"id": "semantic-navigation",
"name": "Semantic Navigation",
"deps": [
"graph-engine",
"km-retriever"
]
}
]
},
{
"id": "km-ai-layer",
"title": "AI Layer",
"items": [
{
"id": "km-retriever",
"name": "Knowledge Retriever",
"deps": [
"km-index"
]
},
{
"id": "km-summarizer",
"name": "Knowledge Summarizer",
"deps": []
},
{
"id": "km-classifier",
"name": "Knowledge Classifier",
"deps": []
},
{
"id": "graph-engine",
"name": "Graph Engine",
"deps": []
}
]
},
{
"id": "km-indexing",
"title": "Indexing & Enrichment",
"items": [
{
"id": "km-index",
"name": "Knowledge Index",
"deps": []
},
{
"id": "tagging-enrichment",
"name": "Automated Tagging & Enrichment",
"deps": [
"km-classifier"
]
},
{
"id": "content-ingestion-km",
"name": "Content Ingestion",
"deps": []
}
]
},
{
"id": "km-infra",
"title": "Knowledge Infrastructure",
"items": [
{
"id": "km-storage",
"name": "Knowledge Storage",
"deps": []
},
{
"id": "identity-service-km",
"name": "Identity Service",
"deps": []
},
{
"id": "access-control-km",
"name": "Access Control",
"deps": [
"identity-service-km"
]
}
]
}
]
},
{
"id": "ai-data-bi",
"title": "AI in Data Analysis & Business Intelligence",
"abstract": "This map explains how AI improves data analysis and BI through automated exploration, predictive modeling, visualization generation, and the pipelines and infrastructure that provide clean, reliable data.",
"categories": [
{
"id": "bi-experiences",
"title": "BI User Experiences",
"items": [
{
"id": "auto-exploration",
"name": "Automated Data Exploration",
"deps": [
"feature-extractor-bi",
"analysis-model-bi"
]
},
{
"id": "predictive-insights",
"name": "Predictive Insights",
"deps": [
"analysis-model-bi",
"metrics-bi",
"model:ai-evaluation-benchmarking",
"ai-evaluation-benchmarking:eval-scores-dashboard"
]
},
{
"id": "auto-visualization",
"name": "Automated Visualization",
"deps": [
"viz-engine",
"feature-extractor-bi"
]
}
]
},
{
"id": "bi-ai-layer",
"title": "AI Layer",
"items": [
{
"id": "analysis-model-bi",
"name": "Analysis Model",
"deps": []
},
{
"id": "viz-engine",
"name": "Visualization Engine",
"deps": []
},
{
"id": "feature-extractor-bi",
"name": "Feature Extractor",
"deps": []
}
]
},
{
"id": "bi-data-pipeline",
"title": "Data Pipeline",
"items": [
{
"id": "data-ingestion-bi",
"name": "Data Ingestion",
"deps": []
},
{
"id": "data-cleaning-bi",
"name": "Data Cleaning",
"deps": [
"data-ingestion-bi"
]
},
{
"id": "data-warehouse-bi",
"name": "Data Warehouse",
"deps": []
},
{
"id": "metrics-bi",
"name": "Metrics Store",
"deps": []
}
]
},
{
"id": "bi-infra",
"title": "BI Infrastructure",
"items": [
{
"id": "query-engine-bi",
"name": "Query Engine",
"deps": [
"data-warehouse-bi"
]
},
{
"id": "identity-service-bi",
"name": "Identity Service",
"deps": []
},
{
"id": "access-control-bi",
"name": "Access Control",
"deps": [
"identity-service-bi"
]
}
]
}
]
}
]