Sync templates from sitemap and reorganize by use case

CONTRIBUTING.md

@@ -1,133 +1,17 @@
-# Contributing to flowzap-workflows
+# Contributing
 
-Thank you for your interest in contributing to the FlowZap workflows corpus! This document provides guidelines for adding new workflows or improving existing ones.
+This repository is synchronized from the FlowZap application template library.
 
-## Workflow Structure
+## Structure
 
-Each workflow must include three files in its own directory:
+- `primary-use-case/source-domain/template-slug/`
+- `workflow.fz` contains the FlowZap Code source
+- `metadata.json` stores machine-readable metadata including primary and secondary Use Cases
+- `templates.index.json`, `use-cases.index.json`, and `metadata.csv` are generated artifacts
 
-```
-domain/workflow-name/
-├── workflow.fz      # FlowZap Code file
-├── README.md        # Human-readable documentation
-└── metadata.json    # Structured metadata
-```
+## Sync Expectations
 
-## FlowZap Code Syntax Rules
-
-### Lane Definition
-```
-LaneName { # Display Name
-  // nodes and edges
-}
-```
-
-### Node Types
-- `circle` - Start/End nodes
-- `rectangle` - Process/Action nodes
-- `diamond` - Decision nodes (must have 2-3 outcomes)
-
-### Node Syntax
-```
-nodeId: nodeType label:"Node Label"
-```
-
-### Edge Syntax
-```
-n1.handle(right) -> n2.handle(left)
-n1.handle(bottom) -> OtherLane.n3.handle(top) [label="Edge Label"]
-```
-
-### Handle Positions
-- `top`, `bottom`, `left`, `right`
-
-## Quality Guidelines
-
-### Do's
-- ✅ Use realistic, domain-specific terminology
-- ✅ Include 2-3 outcomes for diamond (decision) nodes
-- ✅ Use unique node IDs within the workflow
-- ✅ Include cross-lane edges for multi-lane workflows
-- ✅ Add meaningful edge labels for decision branches
-- ✅ Keep workflows between 7-25 nodes
-
-### Don'ts
-- ❌ Reuse node IDs across lanes
-- ❌ Create diamond nodes with only 1 outcome
-- ❌ Use generic labels like "Step 1", "Process"
-- ❌ Omit lane prefixes on cross-lane edges
-- ❌ Create overly complex workflows (>30 nodes)
-
-## Metadata Schema
-
-```json
-{
-  "workflow_id": "kebab-case-id",
-  "domain": "domain-name",
-  "complexity": 3,
-  "num_nodes": 15,
-  "num_lanes": 3,
-  "tags": ["tag1", "tag2", "tag3", "tag4", "tag5", "tag6"],
-  "description": "One-sentence description of the workflow."
-}
-```
-
-### Complexity Scale
-- **1** - Simple (5-7 nodes, 1 lane, no decisions)
-- **2** - Basic (7-10 nodes, 1-2 lanes, 1 decision)
-- **3** - Moderate (10-15 nodes, 2-3 lanes, 2-3 decisions)
-- **4** - Complex (15-20 nodes, 3-4 lanes, multiple decisions)
-- **5** - Advanced (20+ nodes, 4+ lanes, complex branching)
-
-## README Template
-
-```markdown
-# Workflow Title
-
-One-sentence description matching metadata.
-
-**Domain:** domain-name  
-**Complexity:** X/5  
-**Tags:** [tag1, tag2, tag3, tag4, tag5, tag6]
-
-## Lanes
-- **Lane Name** - Role description
-- **Lane Name** - Role description
-
-## Process Flow
-1. First step
-2. Second step
-...
-9. Final step
-```
-
-## Submitting Contributions
-
-1. Fork the repository
-2. Create a new branch for your workflow
-3. Add your workflow files following the structure above
-4. Ensure all three files are present and valid
-5. Submit a pull request with a clear description
-
-## Validation Checklist
-
-Before submitting, verify:
-
-- [ ] `workflow.fz` parses without errors
-- [ ] All node IDs are unique
-- [ ] Diamond nodes have 2-3 labeled outcomes
-- [ ] Cross-lane edges use `Lane.nodeId` syntax
-- [ ] `metadata.json` is valid JSON
-- [ ] `num_nodes` and `num_lanes` match the `.fz` file
-- [ ] `README.md` follows the template
-- [ ] Tags are relevant and kebab-case
-
-## Questions?
-
-- Visit [flowzap.xyz](https://flowzap.xyz) for syntax documentation
-- Check [examples](https://flowzap.xyz/examples) for reference workflows
-- Open an issue for questions or suggestions
-
----
-
-Thank you for helping grow the FlowZap ecosystem!
+- Keep the sitemap-driven template set aligned with `https://flowzap.xyz/sitemap-templates.xml`.
+- Preserve one canonical template copy per slug.
+- Use `primary_use_case` for folder placement and `use_cases` for the full taxonomy membership.
+- Preserve `source_domain` from the app index for traceability.

README.md

@@ -1,188 +1,40 @@
-# flowzap-workflow-sequence-architecture-diagrams
-
-A production-grade corpus of **200+ expert-crafted FlowZap workflow, sequence and architecture files** designed for LLM training, workflow automation learning, and diagrams-as-code reference.
-
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![FlowZap](https://img.shields.io/badge/FlowZap-Code-blue)](https://flowzap.xyz)
-
-## Overview
-This repository contains **600 files** organized as a structured training corpus:
-
-- **200 `.fz` workflow files** - FlowZap Code syntax (diagrams-as-code)
-- **200 `README.md` files** - Human-readable workflow documentation
-- **200 `metadata.json` files** - Structured metadata for programmatic access
-
-> **Looking for ready-to-use templates?** Visit the [FlowZap Templates Library](https://flowzap.xyz/templates) — 250+ templates including workflows, sequence diagrams, and architecture diagrams, with downloadable `.fz` files, n8n JSON exports, and Make.com blueprints.
-
-## What is FlowZap Code?
-FlowZap Code is a diagrams-as-code DSL for creating workflow diagrams, sequence diagrams, and architecture diagrams — all from the same code. Learn more:
-- [FlowZap Website](https://flowzap.xyz)
-- [FlowZap Code Syntax Guide](https://flowzap.xyz/flowzap-code)
-- [AI Coding Guidelines](https://flowzap.xyz/flowzap-code-guidelines.md) — instructions for AI assistants generating FlowZap Code
-- [Templates Library](https://flowzap.xyz/templates) — 250+ ready-to-use templates
-- [Architecture Diagram Templates](https://flowzap.xyz/templates/architecture-diagram-templates) — 50 architecture diagram templates
-
-### Syntax Example
-```
-Warehouse { # Warehouse Team
-  n1: circle label:"Start"
-  n2: rectangle label:"Receive shipment"
-  n3: diamond label:"Inspection passed?"
-  n4: rectangle label:"Stock inventory"
-  n5: rectangle label:"Return to vendor"
-  n6: circle label:"End"
-  
-  n1.handle(right) -> n2.handle(left)
-  n2.handle(right) -> n3.handle(left)
-  n3.handle(right) -> n4.handle(left) [label="Yes"]
-  n3.handle(bottom) -> n5.handle(top) [label="No"]
-  n4.handle(right) -> n6.handle(left)
-  n5.handle(right) -> n6.handle(left)
-}
-```
-
----
-
-## Repository Structure
-```
-flowzap-workflows/
-├── README.md
-├── LICENSE
-├── CONTRIBUTING.md
-├── finance/                    # 21 workflows
-│   ├── monthly-close/
-│   │   ├── workflow.fz
-│   │   ├── README.md
-│   │   └── metadata.json
-│   ├── invoice-processing/
-│   └── ...
-├── hr/                         # 20 workflows
-│   ├── onboarding/
-│   ├── performance-review/
-│   └── ...
-├── logistics/                  # 23 workflows
-│   ├── shipping-process/
-│   ├── inventory-receipt/
-│   └── ...
-├── devops/                     # 15 workflows
-│   ├── ci-cd-pipeline/
-│   ├── incident-response/
-│   └── ...
-├── business-operations/        # 26 workflows
-│   ├── subscription-lifecycle/
-│   ├── support-ticket/
-│   └── ...
-├── patterns/                   # 28 workflows
-│   ├── circuit-breaker/
-│   ├── saga-pattern/
-│   └── ...
-├── edge-cases/                 # Edge case examples
-└── syntax-primitives/          # Basic syntax examples
-```
-
-## Domains Covered
-| Domain | Workflows | Description |
-|--------|-----------|-------------|
-| **Finance** | 21 | Month-end close, AP/AR, treasury, audit, tax |
-| **HR** | 20 | Hiring, onboarding, performance, offboarding |
-| **Logistics** | 23 | WMS, TMS, shipping, inventory, cold chain |
-| **DevOps** | 15 | CI/CD, monitoring, incident response, IaC |
-| **Business Operations** | 26 | SaaS lifecycle, billing, GDPR, OAuth |
-| **Patterns** | 28 | Microservices, event-driven, resilience |
-
-## Metadata Schema
-Each `metadata.json` follows this structure:
-
-```json
-{
-  "workflow_id": "monthly-close",
-  "domain": "finance",
-  "complexity": 4,
-  "num_nodes": 22,
-  "num_lanes": 4,
-  "tags": ["month-end-close", "gaap", "reconciliation", "financial-statements", "accruals", "period-close"],
-  "description": "Month-end financial close workflow with sub-ledger reconciliation, accrual posting, trial balance validation, and financial statement generation."
-}
-```
-
----
-
-## Use Cases
-
-### LLM Training
-This corpus is explicitly designed for training Large Language Models to:
-- Generate FlowZap Code from natural language descriptions
-- Understand workflow patterns across business domains
-- Learn diagrams-as-code syntax
-
-### Learning Resource
-Use these workflows to:
-- Learn FlowZap Code syntax
-- Study real-world workflow patterns
-- Reference best practices for workflow design
-
-### Automation Templates
-Adapt these workflows for:
-- [n8n automation scenarios](https://flowzap.xyz/templates/n8n-workflow-json-examples) — export FlowZap Code as n8n JSON
-- [Make.com (Integromat) workflows](https://flowzap.xyz/templates/make-blueprint-json-examples) — export FlowZap Code as Make.com blueprints
-- Custom workflow engines
-
----
-
-## FlowZap Ecosystem
-
-### Templates Library (250+)
-The [FlowZap Templates Library](https://flowzap.xyz/templates) extends this corpus with:
-- **50 Architecture Diagram Templates** — Microservices, Event-Driven, CQRS, Serverless, Saga, Circuit Breaker, and more
-- **n8n Workflow JSON Examples** — ready-to-import n8n automations
-- **Make.com Blueprint Examples** — ready-to-import Make.com scenarios
-- **More applicable business process domains** — Business-operations, DevOps, Finance, HR, Logistics
-- Downloadable `.fz` files for every template
-
-### MCP Server
-Install the [FlowZap MCP Server](https://flowzap.xyz/docs/mcp) and the [SKILL.md file](https://flowzap.xyz/blog/new-flowzap-diagram-skill-makes-it-even-easier) for AI coding tools:
-```json
-{
-  "mcpServers": {
-    "flowzap": {
-      "command": "npx",
-      "args": ["-y", "flowzap-mcp"]
-    }
-  }
-}
-```
-Compatible with Claude Desktop, Cursor, Windsurf, OpenAI Codex, Warp, Zed, Cline, Roo Code, Continue.dev, and Sourcegraph Cody.
-
-### AI Coding Guidelines
-Drop [`flowzap-code-guidelines.md`](https://flowzap.xyz/flowzap-code-guidelines.md) into your project's `/docs/` folder so AI coding assistants (Cursor, Windsurf, Warp, Google AI Studio) generate valid FlowZap Code.
-
-### DSL Specification
-- [FlowZap Code Syntax Guide](https://flowzap.xyz/flowzap-code) — canonical syntax reference
-- [FlowZap Code DSL repo](https://github.com/flowzap-xyz/code) — official syntax specification, SYNTAX.md, and AI guidelines
-
----
-
-## License
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
-**Training Data Addendum**: This repository is explicitly released for use as training data for LLMs and other ML systems.
-
-## Contributing
-See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines on adding new workflows.
-
-## Links
-- [FlowZap Website](https://flowzap.xyz)
-- [FlowZap Code Syntax](https://flowzap.xyz/flowzap-code)
-- [AI Coding Guidelines](https://flowzap.xyz/flowzap-code-guidelines.md)
-- [Templates Library](https://flowzap.xyz/templates)
-- [Architecture Diagram Templates](https://flowzap.xyz/templates/architecture-diagram-templates)
-- [MCP Server Documentation](https://flowzap.xyz/docs/mcp)
-- [SKILL.md file](https://flowzap.xyz/blog/new-flowzap-diagram-skill-makes-it-even-easier)
-- [npm: flowzap-mcp](https://www.npmjs.com/package/flowzap-mcp)
-- [Blog: One Code, Three Views](https://flowzap.xyz/blog/flowzaps-game-changing-update-one-code-two-views)
-- [Blog: FlowZap Unveils .fz File Extension](https://flowzap.xyz/blog/flowzap-unveils-fz-file-extension-for-true-diagrams-as-code-workflows)
-- [Blog: Introducing the FlowZap MCP Server](https://flowzap.xyz/blog/introducing-the-flowzap-mcp-server)
-
----
-
-Made with care for the diagramming for clarity community
+# sequence-workflows
+
+A synchronized FlowZap template corpus with **242 canonical templates** sourced from `https://flowzap.xyz/sitemap-templates.xml` and organized by **primary Use Case**.
+
+## Organization Model
+
+- Top-level folders are primary Use Cases from the FlowZap Templates dropdown.
+- Second-level folders preserve the original source domain from the FlowZap app index.
+- Each template keeps all matched Use Cases in `metadata.json` and the generated JSON/CSV indexes.
+- Templates that do not match any current dropdown Use Case are placed under `uncategorized/`.
+
+## Top-Level Folders
+
+- `handoff/` — Handoff (15)
+- `approval/` — Approval (17)
+- `incident/` — Incident (10)
+- `onboarding/` — Onboarding (6)
+- `offboarding/` — Offboarding (1)
+- `billing/` — Billing & Payments (8)
+- `security/` — Security & Access (13)
+- `compliance/` — Compliance (13)
+- `delivery/` — Delivery & DevOps (15)
+- `support/` — Support (1)
+- `agentic/` — Agentic Teams (15)
+- `ai-orchestration/` — AI Orchestration (6)
+- `mcp/` — MCP Architecture (10)
+- `context-management/` — Context Management (6)
+- `uncategorized/` — Unmatched canonical templates (106)
+
+## Generated Indexes
+
+- `templates.index.json` — Full machine-readable template index
+- `use-cases.index.json` — Use Case summary with counts and template paths
+- `metadata.csv` — Flat CSV export of core template metadata
+
+## Sync Source
+
+- Canonical URL source: `https://flowzap.xyz/sitemap-templates.xml`
+- Template metadata source: `FlowZap-App-v5/src/templateLibrary/templatesIndex.json`
+- Template file source: `FlowZap-App-v5/public/template-files/*.fz`

agentic/architecture/agentic-hierarchical/README.md

@@ -0,0 +1,19 @@
+# Agentic Hierarchical Architecture
+
+A hierarchical multi-agent architecture with multi-level organizational structure. A top-level executive agent manages mid-level team lead agents, who each manage their own pool of specialist workers. Teams within teams — the hierarchy maps to domain separation.
+
+**Template ID:** `agentic-hierarchical`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** None  
+**Complexity:** 4/5  
+**Nodes:** 8  
+**Lanes:** 7  
+**Tags:** [agentic, hierarchical, multi-agent, enterprise, architecture-diagram, ai-team]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/agentic-hierarchical`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/agentic-hierarchical/metadata.json

@@ -0,0 +1,26 @@
+{
+  "template_id": "agentic-hierarchical",
+  "workflow_id": "agentic-hierarchical",
+  "title": "Agentic Hierarchical Architecture",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [],
+  "use_cases": [
+    "agentic"
+  ],
+  "complexity": 4,
+  "num_nodes": 8,
+  "num_lanes": 7,
+  "tags": [
+    "agentic",
+    "hierarchical",
+    "multi-agent",
+    "enterprise",
+    "architecture-diagram",
+    "ai-team"
+  ],
+  "description": "A hierarchical multi-agent architecture with multi-level organizational structure. A top-level executive agent manages mid-level team lead agents, who each manage their own pool of specialist workers. Teams within teams — the hierarchy maps to domain separation.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/agentic-hierarchical"
+}

agentic/architecture/agentic-hierarchical/workflow.fz

@@ -0,0 +1,36 @@
+executive_agent {# Executive Agent
+  n1: rectangle label="Route Master Goal"
+  n1.handle(bottom) -> research_lead_agent.n2.handle(top) [label="Assign Research"]
+  n1.handle(bottom) -> content_lead_agent.n5.handle(top) [label="Assign Content"]
+}
+
+research_lead_agent {# Research Lead Agent
+  n2: rectangle label="Manage Retrieval Team"
+  n2.handle(bottom) -> web_search_agent.n3.handle(top) [label="Web Task"]
+  n2.handle(bottom) -> db_retrieval_agent.n4.handle(top) [label="DB Task"]
+}
+
+web_search_agent {# Web Search Agent
+  n3: rectangle label="Live Web Search"
+  n3.handle(right) -> research_lead_agent.n2.handle(right) [label="Web Data"]
+}
+
+db_retrieval_agent {# DB Retrieval Agent
+  n4: rectangle label="Internal Knowledge RAG"
+  n4.handle(right) -> research_lead_agent.n2.handle(right) [label="Internal Data"]
+}
+
+content_lead_agent {# Content Lead Agent
+  n5: rectangle label="Manage Production Team"
+  n5.handle(bottom) -> writer_agent.n6.handle(top) [label="Draft Topic"]
+}
+
+writer_agent {# Writer Agent
+  n6: rectangle label="Draft Document"
+  n6.handle(bottom) -> qa_agent.n7.handle(top) [label="Draft Text"]
+}
+
+qa_agent {# QA Agent
+  n7: rectangle label="Fact Check"
+  n7.handle(right) -> content_lead_agent.n5.handle(right) [label="Final Content"]
+}

agentic/architecture/agentic-supervisor-worker/README.md

@@ -0,0 +1,19 @@
+# Agentic Supervisor-Worker Architecture
+
+A supervisor-worker multi-agent architecture where an orchestrator agent receives a high-level goal, breaks it into subtasks, delegates each to specialist worker agents (researcher, writer, QA), monitors execution, handles failures, and synthesizes results. The orchestrator manages but does not execute tasks itself.
+
+**Template ID:** `agentic-supervisor-worker`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** None  
+**Complexity:** 3/5  
+**Nodes:** 10  
+**Lanes:** 4  
+**Tags:** [agentic, supervisor-worker, multi-agent, orchestrator, architecture-diagram, ai-team]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/agentic-supervisor-worker`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/agentic-supervisor-worker/metadata.json

@@ -0,0 +1,26 @@
+{
+  "template_id": "agentic-supervisor-worker",
+  "workflow_id": "agentic-supervisor-worker",
+  "title": "Agentic Supervisor-Worker Architecture",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [],
+  "use_cases": [
+    "agentic"
+  ],
+  "complexity": 3,
+  "num_nodes": 10,
+  "num_lanes": 4,
+  "tags": [
+    "agentic",
+    "supervisor-worker",
+    "multi-agent",
+    "orchestrator",
+    "architecture-diagram",
+    "ai-team"
+  ],
+  "description": "A supervisor-worker multi-agent architecture where an orchestrator agent receives a high-level goal, breaks it into subtasks, delegates each to specialist worker agents (researcher, writer, QA), monitors execution, handles failures, and synthesizes results. The orchestrator manages but does not execute tasks itself.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/agentic-supervisor-worker"
+}

agentic/architecture/agentic-supervisor-worker/workflow.fz

@@ -0,0 +1,29 @@
+orchestrator_agent {# Orchestrator Agent
+  n1: rectangle label="Decompose & Manage Subtasks"
+  n5: diamond label="All Passed QA?"
+  n6: rectangle label="Synthesize Final Result"
+
+  n1.handle(bottom) -> researcher_agent.n2.handle(top) [label="Task: Gather Sources"]
+  n1.handle(bottom) -> writer_agent.n3.handle(top) [label="Task: Draft"]
+  n1.handle(bottom) -> qa_agent.n4.handle(top) [label="Task: Review"]
+
+  n5.handle(right) -> n6.handle(left) [label="Yes"]
+  n5.handle(top) -> writer_agent.n3.handle(top) [label="No (Fix Draft)"]
+}
+
+researcher_agent {# Research Agent
+  n2: rectangle label="Retrieve Information (Web/RAG)"
+  n2.handle(right) -> orchestrator_agent.n1.handle(right) [label="Summary"]
+}
+
+writer_agent {# Writer Agent
+  n3: rectangle label="Generate Text"
+  n3.handle(right) -> orchestrator_agent.n1.handle(right) [label="Draft"]
+}
+
+qa_agent {# QA Agent
+  n4: rectangle label="Review Output"
+  n4.handle(right) -> orchestrator_agent.n5.handle(left) [label="Flags"]
+}
+
+loop [retry loop] writer_agent.n3 qa_agent.n4 orchestrator_agent.n5

agentic/architecture/agentic-swarm/README.md

@@ -0,0 +1,19 @@
+# Agentic Swarm Architecture
+
+A swarm multi-agent architecture where multiple agents work on the same or related tasks simultaneously, with no central coordinator. Their outputs are then aggregated, voted on, or merged by a dedicated aggregator node. Agents may compete — the best output wins.
+
+**Template ID:** `agentic-swarm`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** None  
+**Complexity:** 3/5  
+**Nodes:** 6  
+**Lanes:** 5  
+**Tags:** [agentic, swarm, multi-agent, parallel, aggregator, architecture-diagram, ai-team]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/agentic-swarm`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/agentic-swarm/metadata.json

@@ -0,0 +1,27 @@
+{
+  "template_id": "agentic-swarm",
+  "workflow_id": "agentic-swarm",
+  "title": "Agentic Swarm Architecture",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [],
+  "use_cases": [
+    "agentic"
+  ],
+  "complexity": 3,
+  "num_nodes": 6,
+  "num_lanes": 5,
+  "tags": [
+    "agentic",
+    "swarm",
+    "multi-agent",
+    "parallel",
+    "aggregator",
+    "architecture-diagram",
+    "ai-team"
+  ],
+  "description": "A swarm multi-agent architecture where multiple agents work on the same or related tasks simultaneously, with no central coordinator. Their outputs are then aggregated, voted on, or merged by a dedicated aggregator node. Agents may compete — the best output wins.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/agentic-swarm"
+}

agentic/architecture/agentic-swarm/workflow.fz

@@ -0,0 +1,25 @@
+dispatcher_agent {# Dispatcher Agent
+  n1: rectangle label="Split Goals & Dispatch"
+  n1.handle(bottom) -> research_agent_a.n2.handle(top) [label="Explore Angle 1"]
+  n1.handle(bottom) -> research_agent_b.n3.handle(top) [label="Explore Angle 2"]
+  n1.handle(bottom) -> research_agent_c.n4.handle(top) [label="Explore Angle 3"]
+}
+
+research_agent_a {# Research Agent A
+  n2: rectangle label="Parallel Search A"
+  n2.handle(bottom) -> aggregator_agent.n5.handle(top) [label="Findings A"]
+}
+
+research_agent_b {# Research Agent B
+  n3: rectangle label="Parallel Search B"
+  n3.handle(bottom) -> aggregator_agent.n5.handle(top) [label="Findings B"]
+}
+
+research_agent_c {# Research Agent C
+  n4: rectangle label="Parallel Search C"
+  n4.handle(bottom) -> aggregator_agent.n5.handle(top) [label="Findings C"]
+}
+
+aggregator_agent {# Aggregator Agent
+  n5: rectangle label="Merge & Deduplicate"
+}

agentic/architecture/agentic-team-of-rivals/README.md

@@ -0,0 +1,19 @@
+# Agentic Team of Rivals Architecture
+
+The most architecturally sophisticated multi-agent pattern. Agents are assigned not just roles but opposing incentives. A Planner is optimistic about goal completion. A Critic is constitutionally skeptical and holds veto authority. Errors get caught through adversarial pressure rather than trusting a single model's self-assessment.
+
+**Template ID:** `agentic-team-of-rivals`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** None  
+**Complexity:** 3/5  
+**Nodes:** 5  
+**Lanes:** 3  
+**Tags:** [agentic, team-of-rivals, multi-agent, critic, veto, architecture-diagram, ai-team]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/agentic-team-of-rivals`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/agentic-team-of-rivals/metadata.json

@@ -0,0 +1,27 @@
+{
+  "template_id": "agentic-team-of-rivals",
+  "workflow_id": "agentic-team-of-rivals",
+  "title": "Agentic Team of Rivals Architecture",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [],
+  "use_cases": [
+    "agentic"
+  ],
+  "complexity": 3,
+  "num_nodes": 5,
+  "num_lanes": 3,
+  "tags": [
+    "agentic",
+    "team-of-rivals",
+    "multi-agent",
+    "critic",
+    "veto",
+    "architecture-diagram",
+    "ai-team"
+  ],
+  "description": "The most architecturally sophisticated multi-agent pattern. Agents are assigned not just roles but opposing incentives. A Planner is optimistic about goal completion. A Critic is constitutionally skeptical and holds veto authority. Errors get caught through adversarial pressure rather than trusting a single model's self-assessment.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/agentic-team-of-rivals"
+}

agentic/architecture/agentic-team-of-rivals/workflow.fz

@@ -0,0 +1,19 @@
+planner_agent {# Planner Agent
+  n1: rectangle label="Declare Step-by-Step Plan & Acceptance Criteria"
+  n1.handle(right) -> executor_agent.n2.handle(left) [label="Task Plan + Criteria"]
+}
+
+executor_agent {# Executor Agent
+  n2: rectangle label="Execute Remote Code & Tools"
+  n2.handle(right) -> critic_agent.n3.handle(left) [label="Execution Summary"]
+}
+
+critic_agent {# Critic Agent
+  n3: rectangle label="Validate vs Acceptance Criteria"
+  n4: diamond label="Passed Gate?"
+
+  n3.handle(bottom) -> n4.handle(top)
+  n4.handle(top) -> planner_agent.n1.handle(bottom) [label="Veto (Reject & Explain)"]
+}
+
+loop [Rejection Iteration] planner_agent.n1 executor_agent.n2 critic_agent.n3 critic_agent.n4

agentic/architecture/ai-native-event-driven-kafka-architecture/README.md

@@ -0,0 +1,19 @@
+# AI-Native Event-Driven Kafka Architecture
+
+An event-driven agentic AI architecture that replaces the central orchestrator with Kafka/PubSub topics: agents subscribe, react, and publish new events. This aligns multi-agent systems with proven microservices choreography and is ideal for real-time, high-throughput systems and 'agent mesh' setups.
+
+**Template ID:** `ai-native-event-driven-kafka-architecture`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** ai-orchestration, mcp  
+**Complexity:** 3/5  
+**Nodes:** 12  
+**Lanes:** 5  
+**Tags:** [ai-native, event-driven, agentic-ai, kafka, pub-sub, agent-mesh, architecture-diagram]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/ai-native-event-driven-kafka-architecture`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/ai-native-event-driven-kafka-architecture/metadata.json

@@ -0,0 +1,32 @@
+{
+  "template_id": "ai-native-event-driven-kafka-architecture",
+  "workflow_id": "ai-native-event-driven-kafka-architecture",
+  "title": "AI-Native Event-Driven Kafka Architecture",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [
+    "ai-orchestration",
+    "mcp"
+  ],
+  "use_cases": [
+    "agentic",
+    "ai-orchestration",
+    "mcp"
+  ],
+  "complexity": 3,
+  "num_nodes": 12,
+  "num_lanes": 5,
+  "tags": [
+    "ai-native",
+    "event-driven",
+    "agentic-ai",
+    "kafka",
+    "pub-sub",
+    "agent-mesh",
+    "architecture-diagram"
+  ],
+  "description": "An event-driven agentic AI architecture that replaces the central orchestrator with Kafka/PubSub topics: agents subscribe, react, and publish new events. This aligns multi-agent systems with proven microservices choreography and is ideal for real-time, high-throughput systems and 'agent mesh' setups.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/ai-native-event-driven-kafka-architecture"
+}

agentic/architecture/ai-native-event-driven-kafka-architecture/workflow.fz

@@ -0,0 +1,35 @@
+Source { # Event Sources
+n1: circle label:"Start"
+n2: rectangle label:"User action event"
+n3: rectangle label:"System alert event"
+n1.handle(right) -> n2.handle(left)
+n2.handle(bottom) -> Broker.n4.handle(top) [label="Publish event"]
+n3.handle(bottom) -> Broker.n4.handle(top) [label="Publish event"]
+}
+Broker { # Event Broker (Kafka / Pub-Sub)
+n4: rectangle label:"Event bus receives event"
+n5: rectangle label:"Route to subscribers"
+n4.handle(right) -> n5.handle(left)
+n5.handle(bottom) -> Orders.n6.handle(top) [label="topic: orders"]
+n5.handle(bottom) -> Alerts.n8.handle(top) [label="topic: alerts"]
+n5.handle(bottom) -> Analytics.n10.handle(top) [label="topic: analytics"]
+}
+Orders { # Order Processing Agent
+n6: rectangle label:"Parse order event"
+n7: rectangle label:"Execute fulfillment"
+n6.handle(right) -> n7.handle(left)
+n7.handle(bottom) -> Broker.n4.handle(top) [label="Publish: order.completed"]
+}
+Alerts { # Alert Triage Agent
+n8: rectangle label:"Classify severity"
+n9: rectangle label:"Route to on-call or auto-resolve"
+n8.handle(right) -> n9.handle(left)
+n9.handle(bottom) -> Broker.n4.handle(top) [label="Publish: alert.resolved"]
+}
+Analytics { # Analytics Agent
+n10: rectangle label:"Aggregate metrics"
+n11: rectangle label:"Update dashboard"
+n12: circle label:"Stored"
+n10.handle(right) -> n11.handle(left)
+n11.handle(right) -> n12.handle(left)
+}

agentic/architecture/ai-native-generator-critic-architecture/README.md

@@ -0,0 +1,19 @@
+# AI-Native Generator-Critic Architecture
+
+A competitive / generator-critic architecture where multiple generators produce independent answers, then an evaluator agent scores and selects the best output. This approach improves quality and reduces single-model brittleness. It's costlier (multiple LLM calls) but pays off when correctness or creativity matters more than latency.
+
+**Template ID:** `ai-native-generator-critic-architecture`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** ai-orchestration  
+**Complexity:** 3/5  
+**Nodes:** 9  
+**Lanes:** 3  
+**Tags:** [ai-native, generator-critic, agentic-ai, tournament-mode, multi-agent, architecture-diagram]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/ai-native-generator-critic-architecture`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/ai-native-generator-critic-architecture/metadata.json

@@ -0,0 +1,29 @@
+{
+  "template_id": "ai-native-generator-critic-architecture",
+  "workflow_id": "ai-native-generator-critic-architecture",
+  "title": "AI-Native Generator-Critic Architecture",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [
+    "ai-orchestration"
+  ],
+  "use_cases": [
+    "agentic",
+    "ai-orchestration"
+  ],
+  "complexity": 3,
+  "num_nodes": 9,
+  "num_lanes": 3,
+  "tags": [
+    "ai-native",
+    "generator-critic",
+    "agentic-ai",
+    "tournament-mode",
+    "multi-agent",
+    "architecture-diagram"
+  ],
+  "description": "A competitive / generator-critic architecture where multiple generators produce independent answers, then an evaluator agent scores and selects the best output. This approach improves quality and reduces single-model brittleness. It's costlier (multiple LLM calls) but pays off when correctness or creativity matters more than latency.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/ai-native-generator-critic-architecture"
+}

agentic/architecture/ai-native-generator-critic-architecture/workflow.fz

@@ -0,0 +1,27 @@
+Input { # Input
+n1: circle label:"Start"
+n2: rectangle label:"Creative brief submitted"
+n1.handle(right) -> n2.handle(left)
+n2.handle(bottom) -> Generators.n3.handle(top) [label="Brief"]
+n2.handle(bottom) -> Generators.n4.handle(top) [label="Brief"]
+n2.handle(bottom) -> Generators.n5.handle(top) [label="Brief"]
+}
+Generators { # Generator Agents
+n3: rectangle label:"Agent A: Draft option 1"
+n4: rectangle label:"Agent B: Draft option 2"
+n5: rectangle label:"Agent C: Draft option 3"
+n3.handle(bottom) -> Evaluator.n6.handle(top) [label="Option 1"]
+n4.handle(bottom) -> Evaluator.n6.handle(top) [label="Option 2"]
+n5.handle(bottom) -> Evaluator.n6.handle(top) [label="Option 3"]
+}
+Evaluator { # Evaluator Agent
+n6: rectangle label:"Score all options"
+n7: diamond label:"Quality threshold met?"
+n8: rectangle label:"Select best output"
+n9: circle label:"Done"
+n6.handle(right) -> n7.handle(left)
+n7.handle(right) -> n8.handle(left) [label="Yes"]
+n7.handle(top) -> Generators.n3.handle(bottom) [label="No - Refine"]
+n8.handle(right) -> n9.handle(left)
+loop [refine until quality threshold met] n3 n4 n5 n6 n7
+}

agentic/architecture/ai-native-hierarchical-architecture/README.md

@@ -0,0 +1,19 @@
+# AI-Native Hierarchical Architecture
+
+A hierarchical multi-agent architecture that scales orchestration by stacking supervisors and team leads (a tree structure), which mirrors enterprise org structures and helps partition context. This is the 'enterprise-grade agentic AI architecture' when a single orchestrator cannot manage all workers directly. Ideal for large enterprises and multi-domain workflows.
+
+**Template ID:** `ai-native-hierarchical-architecture`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** ai-orchestration  
+**Complexity:** 4/5  
+**Nodes:** 16  
+**Lanes:** 4  
+**Tags:** [ai-native, hierarchical, agentic-ai, enterprise, multi-agent, architecture-diagram]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/ai-native-hierarchical-architecture`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/ai-native-hierarchical-architecture/metadata.json

@@ -0,0 +1,29 @@
+{
+  "template_id": "ai-native-hierarchical-architecture",
+  "workflow_id": "ai-native-hierarchical-architecture",
+  "title": "AI-Native Hierarchical Architecture",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [
+    "ai-orchestration"
+  ],
+  "use_cases": [
+    "agentic",
+    "ai-orchestration"
+  ],
+  "complexity": 4,
+  "num_nodes": 16,
+  "num_lanes": 4,
+  "tags": [
+    "ai-native",
+    "hierarchical",
+    "agentic-ai",
+    "enterprise",
+    "multi-agent",
+    "architecture-diagram"
+  ],
+  "description": "A hierarchical multi-agent architecture that scales orchestration by stacking supervisors and team leads (a tree structure), which mirrors enterprise org structures and helps partition context. This is the 'enterprise-grade agentic AI architecture' when a single orchestrator cannot manage all workers directly. Ideal for large enterprises and multi-domain workflows.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/ai-native-hierarchical-architecture"
+}

agentic/architecture/ai-native-hierarchical-architecture/workflow.fz

@@ -0,0 +1,45 @@
+User { # User
+n1: circle label:"Start"
+n2: rectangle label:"Submit enterprise request"
+n1.handle(right) -> n2.handle(left)
+n2.handle(bottom) -> Supervisor.n3.handle(top) [label="Goal"]
+}
+Supervisor { # Top-Level Supervisor
+n3: rectangle label:"Decompose goal"
+n4: rectangle label:"Delegate to team leads"
+n5: rectangle label:"Aggregate final output"
+n6: circle label:"Done"
+n3.handle(right) -> n4.handle(left)
+n4.handle(bottom) -> LeadA.n7.handle(top) [label="Sub-goal A"]
+n4.handle(bottom) -> LeadB.n10.handle(top) [label="Sub-goal B"]
+n5.handle(right) -> n6.handle(left)
+n5.handle(top) -> User.n2.handle(bottom) [label="Final report"]
+}
+LeadA { # Team Lead A
+n7: rectangle label:"Plan subtasks for A"
+n8: rectangle label:"Dispatch to workers"
+n9: rectangle label:"Consolidate A results"
+n7.handle(right) -> n8.handle(left)
+n8.handle(bottom) -> Workers.n13.handle(top) [label="Task A1"]
+n8.handle(bottom) -> Workers.n14.handle(top) [label="Task A2"]
+n9.handle(top) -> Supervisor.n5.handle(bottom) [label="Result A"]
+}
+LeadB { # Team Lead B
+n10: rectangle label:"Plan subtasks for B"
+n11: rectangle label:"Dispatch to workers"
+n12: rectangle label:"Consolidate B results"
+n10.handle(right) -> n11.handle(left)
+n11.handle(bottom) -> Workers.n15.handle(top) [label="Task B1"]
+n11.handle(bottom) -> Workers.n16.handle(top) [label="Task B2"]
+n12.handle(top) -> Supervisor.n5.handle(bottom) [label="Result B"]
+}
+Workers { # Worker Agents
+n13: rectangle label:"Worker A1 executes"
+n14: rectangle label:"Worker A2 executes"
+n15: rectangle label:"Worker B1 executes"
+n16: rectangle label:"Worker B2 executes"
+n13.handle(top) -> LeadA.n9.handle(bottom) [label="A1 done"]
+n14.handle(top) -> LeadA.n9.handle(bottom) [label="A2 done"]
+n15.handle(top) -> LeadB.n12.handle(bottom) [label="B1 done"]
+n16.handle(top) -> LeadB.n12.handle(bottom) [label="B2 done"]
+}

agentic/architecture/ai-native-orchestrator-worker-architecture/README.md

@@ -0,0 +1,19 @@
+# AI-Native Orchestrator-Worker Architecture
+
+An orchestrator-worker architecture where an orchestrator agent breaks a goal into subtasks, dispatches to specialized workers, then synthesizes a final response. This is the most common 'agent orchestration' architecture—powerful but the orchestrator can become a bottleneck as the number of workers grows. Frameworks like LangGraph focus on explicit routing/state to manage this.
+
+**Template ID:** `ai-native-orchestrator-worker-architecture`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** ai-orchestration  
+**Complexity:** 3/5  
+**Nodes:** 14  
+**Lanes:** 4  
+**Tags:** [ai-native, orchestrator-worker, agentic-ai, langgraph, multi-agent, architecture-diagram]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/ai-native-orchestrator-worker-architecture`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/ai-native-orchestrator-worker-architecture/metadata.json

@@ -0,0 +1,29 @@
+{
+  "template_id": "ai-native-orchestrator-worker-architecture",
+  "workflow_id": "ai-native-orchestrator-worker-architecture",
+  "title": "AI-Native Orchestrator-Worker Architecture",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [
+    "ai-orchestration"
+  ],
+  "use_cases": [
+    "agentic",
+    "ai-orchestration"
+  ],
+  "complexity": 3,
+  "num_nodes": 14,
+  "num_lanes": 4,
+  "tags": [
+    "ai-native",
+    "orchestrator-worker",
+    "agentic-ai",
+    "langgraph",
+    "multi-agent",
+    "architecture-diagram"
+  ],
+  "description": "An orchestrator-worker architecture where an orchestrator agent breaks a goal into subtasks, dispatches to specialized workers, then synthesizes a final response. This is the most common 'agent orchestration' architecture—powerful but the orchestrator can become a bottleneck as the number of workers grows. Frameworks like LangGraph focus on explicit routing/state to manage this.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/ai-native-orchestrator-worker-architecture"
+}

agentic/architecture/ai-native-orchestrator-worker-architecture/workflow.fz

@@ -0,0 +1,40 @@
+User { # User
+n1: circle label:"Start"
+n2: rectangle label:"Submit complex task"
+n1.handle(right) -> n2.handle(left)
+n2.handle(bottom) -> Orchestrator.n3.handle(top) [label="Task"]
+}
+Orchestrator { # Orchestrator Agent
+n3: rectangle label:"Receive task"
+n4: rectangle label:"Break into subtasks"
+n5: rectangle label:"Dispatch subtasks"
+n6: rectangle label:"Collect results"
+n7: rectangle label:"Synthesize final answer"
+n8: circle label:"Done"
+n3.handle(right) -> n4.handle(left)
+n4.handle(right) -> n5.handle(left)
+n5.handle(bottom) -> Research.n9.handle(top) [label="Research subtask"]
+n5.handle(bottom) -> Code.n11.handle(top) [label="Code subtask"]
+n5.handle(bottom) -> Review.n13.handle(top) [label="Review subtask"]
+n6.handle(right) -> n7.handle(left)
+n7.handle(right) -> n8.handle(left)
+n7.handle(top) -> User.n2.handle(bottom) [label="Response"]
+}
+Research { # Research Agent
+n9: rectangle label:"Search sources"
+n10: rectangle label:"Summarize findings"
+n9.handle(right) -> n10.handle(left)
+n10.handle(top) -> Orchestrator.n6.handle(bottom) [label="Research result"]
+}
+Code { # Code Agent
+n11: rectangle label:"Generate code"
+n12: rectangle label:"Run tests"
+n11.handle(right) -> n12.handle(left)
+n12.handle(top) -> Orchestrator.n6.handle(bottom) [label="Code result"]
+}
+Review { # Review Agent
+n13: rectangle label:"Evaluate quality"
+n14: rectangle label:"Flag issues"
+n13.handle(right) -> n14.handle(left)
+n14.handle(top) -> Orchestrator.n6.handle(bottom) [label="Review result"]
+}

agentic/architecture/ai-native-single-agent-architecture/README.md

@@ -0,0 +1,19 @@
+# AI-Native Single Agent Architecture
+
+A single-agent AI architecture where one agent handles everything: parsing requests, reasoning, calling tools via MCP, and generating responses. This is the default architecture for prototypes and simple automations—easy to debug but hits context-window limits quickly and is hard to parallelize. Ideal for MVPs and solo builders shipping fast.
+
+**Template ID:** `ai-native-single-agent-architecture`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** ai-orchestration, mcp  
+**Complexity:** 2/5  
+**Nodes:** 11  
+**Lanes:** 3  
+**Tags:** [ai-native, single-agent, agentic-ai, mcp, architecture-diagram]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/ai-native-single-agent-architecture`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/ai-native-single-agent-architecture/metadata.json

@@ -0,0 +1,30 @@
+{
+  "template_id": "ai-native-single-agent-architecture",
+  "workflow_id": "ai-native-single-agent-architecture",
+  "title": "AI-Native Single Agent Architecture",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [
+    "ai-orchestration",
+    "mcp"
+  ],
+  "use_cases": [
+    "agentic",
+    "ai-orchestration",
+    "mcp"
+  ],
+  "complexity": 2,
+  "num_nodes": 11,
+  "num_lanes": 3,
+  "tags": [
+    "ai-native",
+    "single-agent",
+    "agentic-ai",
+    "mcp",
+    "architecture-diagram"
+  ],
+  "description": "A single-agent AI architecture where one agent handles everything: parsing requests, reasoning, calling tools via MCP, and generating responses. This is the default architecture for prototypes and simple automations—easy to debug but hits context-window limits quickly and is hard to parallelize. Ideal for MVPs and solo builders shipping fast.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/ai-native-single-agent-architecture"
+}

agentic/architecture/ai-native-single-agent-architecture/workflow.fz

@@ -0,0 +1,29 @@
+User { # User
+n1: circle label:"Start"
+n2: rectangle label:"Send request"
+n1.handle(right) -> n2.handle(left)
+n2.handle(bottom) -> Agent.n3.handle(top) [label="Request"]
+}
+Agent { # Single AI Agent
+n3: rectangle label:"Receive input"
+n4: rectangle label:"Reason and plan"
+n5: rectangle label:"Decide tool call"
+n6: rectangle label:"Process tool result"
+n7: rectangle label:"Generate response"
+n8: circle label:"Done"
+n3.handle(right) -> n4.handle(left)
+n4.handle(right) -> n5.handle(left)
+n5.handle(bottom) -> Tools.n9.handle(top) [label="MCP request"]
+n6.handle(right) -> n7.handle(left)
+n7.handle(right) -> n8.handle(left)
+n7.handle(top) -> User.n2.handle(bottom) [label="Response"]
+loop [retry until goal met] n4 n5 n6 n7
+}
+Tools { # Tool Server (MCP)
+n9: rectangle label:"Receive MCP call"
+n10: rectangle label:"Execute tool"
+n11: rectangle label:"Return result"
+n9.handle(right) -> n10.handle(left)
+n10.handle(right) -> n11.handle(left)
+n11.handle(top) -> Agent.n6.handle(bottom) [label="Tool result"]
+}

agentic/architecture/ai-orchestration-competitive-generator-critic/README.md

@@ -0,0 +1,19 @@
+# AI Orchestration - Competitive Generator-Critic
+
+A tournament-mode architecture where multiple generator agents produce independent outputs in parallel, then an evaluator agent scores and selects the best. Quality threshold checking with refinement loops. Best when correctness or creativity matters more than latency.
+
+**Template ID:** `ai-orchestration-competitive-generator-critic`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** ai-orchestration  
+**Complexity:** 3/5  
+**Nodes:** 10  
+**Lanes:** 3  
+**Tags:** [ai-native, competitive, generator-critic, tournament, multi-agent, architecture-diagram, orchestration]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/ai-orchestration-competitive-generator-critic`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/ai-orchestration-competitive-generator-critic/metadata.json

@@ -0,0 +1,30 @@
+{
+  "template_id": "ai-orchestration-competitive-generator-critic",
+  "workflow_id": "ai-orchestration-competitive-generator-critic",
+  "title": "AI Orchestration - Competitive Generator-Critic",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [
+    "ai-orchestration"
+  ],
+  "use_cases": [
+    "agentic",
+    "ai-orchestration"
+  ],
+  "complexity": 3,
+  "num_nodes": 10,
+  "num_lanes": 3,
+  "tags": [
+    "ai-native",
+    "competitive",
+    "generator-critic",
+    "tournament",
+    "multi-agent",
+    "architecture-diagram",
+    "orchestration"
+  ],
+  "description": "A tournament-mode architecture where multiple generator agents produce independent outputs in parallel, then an evaluator agent scores and selects the best. Quality threshold checking with refinement loops. Best when correctness or creativity matters more than latency.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/ai-orchestration-competitive-generator-critic"
+}

agentic/architecture/ai-orchestration-competitive-generator-critic/workflow.fz

@@ -0,0 +1,29 @@
+Input { # Input
+  n1: circle label="Start"
+  n2: rectangle label="Creative brief submitted"
+  n1.handle(right) -> n2.handle(left)
+  n2.handle(bottom) -> Generators.n3.handle(top) [label="Brief"]
+  n2.handle(bottom) -> Generators.n4.handle(top) [label="Brief"]
+  n2.handle(bottom) -> Generators.n5.handle(top) [label="Brief"]
+}
+
+Generators { # Generator Agents
+  n3: rectangle label="Agent A: Draft option 1"
+  n4: rectangle label="Agent B: Draft option 2"
+  n5: rectangle label="Agent C: Draft option 3"
+  n3.handle(bottom) -> Evaluator.n6.handle(top) [label="Option 1"]
+  n4.handle(bottom) -> Evaluator.n6.handle(top) [label="Option 2"]
+  n5.handle(bottom) -> Evaluator.n6.handle(top) [label="Option 3"]
+}
+
+Evaluator { # Evaluator Agent
+  n6: rectangle label="Score all options"
+  n7: diamond label="Quality threshold met?"
+  n8: rectangle label="Select best output"
+  n9: circle label="Done"
+  n6.handle(right) -> n7.handle(left)
+  n7.handle(right) -> n8.handle(left) [label="Yes"]
+  n7.handle(top) -> Generators.n3.handle(bottom) [label="No - Refine"]
+  n8.handle(right) -> n9.handle(left)
+  loop [refine until quality threshold met] n3 n4 n5 n6 n7
+}

agentic/architecture/ai-orchestration-hierarchical/README.md

@@ -0,0 +1,19 @@
+# AI Orchestration - Hierarchical (Org Chart)
+
+An org-chart architecture with multi-level structure. A top-level supervisor manages team leads, who each manage their own pool of specialist workers. Teams within teams. Best for enterprise-scale automation with 10+ specialized agents spanning multiple domains.
+
+**Template ID:** `ai-orchestration-hierarchical`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** ai-orchestration  
+**Complexity:** 4/5  
+**Nodes:** 17  
+**Lanes:** 5  
+**Tags:** [ai-native, hierarchical, org-chart, enterprise, multi-agent, architecture-diagram, orchestration]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/ai-orchestration-hierarchical`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/ai-orchestration-hierarchical/metadata.json

@@ -0,0 +1,30 @@
+{
+  "template_id": "ai-orchestration-hierarchical",
+  "workflow_id": "ai-orchestration-hierarchical",
+  "title": "AI Orchestration - Hierarchical (Org Chart)",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [
+    "ai-orchestration"
+  ],
+  "use_cases": [
+    "agentic",
+    "ai-orchestration"
+  ],
+  "complexity": 4,
+  "num_nodes": 17,
+  "num_lanes": 5,
+  "tags": [
+    "ai-native",
+    "hierarchical",
+    "org-chart",
+    "enterprise",
+    "multi-agent",
+    "architecture-diagram",
+    "orchestration"
+  ],
+  "description": "An org-chart architecture with multi-level structure. A top-level supervisor manages team leads, who each manage their own pool of specialist workers. Teams within teams. Best for enterprise-scale automation with 10+ specialized agents spanning multiple domains.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/ai-orchestration-hierarchical"
+}

agentic/architecture/ai-orchestration-hierarchical/workflow.fz

@@ -0,0 +1,49 @@
+User { # User
+  n1: circle label="Start"
+  n2: rectangle label="Submit enterprise request"
+  n1.handle(right) -> n2.handle(left)
+  n2.handle(bottom) -> Supervisor.n3.handle(top) [label="Goal"]
+}
+
+Supervisor { # Top-Level Supervisor
+  n3: rectangle label="Decompose goal"
+  n4: rectangle label="Delegate to team leads"
+  n5: rectangle label="Aggregate final output"
+  n6: circle label="Done"
+  n3.handle(right) -> n4.handle(left)
+  n4.handle(bottom) -> LeadA.n7.handle(top) [label="Sub-goal A"]
+  n4.handle(bottom) -> LeadB.n10.handle(top) [label="Sub-goal B"]
+  n5.handle(right) -> n6.handle(left)
+  n5.handle(top) -> User.n2.handle(bottom) [label="Final report"]
+}
+
+LeadA { # Team Lead A
+  n7: rectangle label="Plan subtasks for A"
+  n8: rectangle label="Dispatch to workers"
+  n9: rectangle label="Consolidate A results"
+  n7.handle(right) -> n8.handle(left)
+  n8.handle(bottom) -> Workers.n13.handle(top) [label="Task A1"]
+  n8.handle(bottom) -> Workers.n14.handle(top) [label="Task A2"]
+  n9.handle(top) -> Supervisor.n5.handle(bottom) [label="Result A"]
+}
+
+LeadB { # Team Lead B
+  n10: rectangle label="Plan subtasks for B"
+  n11: rectangle label="Dispatch to workers"
+  n12: rectangle label="Consolidate B results"
+  n10.handle(right) -> n11.handle(left)
+  n11.handle(bottom) -> Workers.n15.handle(top) [label="Task B1"]
+  n11.handle(bottom) -> Workers.n16.handle(top) [label="Task B2"]
+  n12.handle(top) -> Supervisor.n5.handle(bottom) [label="Result B"]
+}
+
+Workers { # Worker Agents
+  n13: rectangle label="Worker A1 executes"
+  n14: rectangle label="Worker A2 executes"
+  n15: rectangle label="Worker B1 executes"
+  n16: rectangle label="Worker B2 executes"
+  n13.handle(top) -> LeadA.n9.handle(bottom) [label="A1 done"]
+  n14.handle(top) -> LeadA.n9.handle(bottom) [label="A2 done"]
+  n15.handle(top) -> LeadB.n12.handle(bottom) [label="B1 done"]
+  n16.handle(top) -> LeadB.n12.handle(bottom) [label="B2 done"]
+}

agentic/architecture/ai-orchestration-orchestrator-worker/README.md

@@ -0,0 +1,19 @@
+# AI Orchestration - Orchestrator-Worker
+
+A conductor-style architecture where one orchestrator agent receives a complex task, breaks it into subtasks, dispatches each to specialist worker agents (research, code, review), collects results, and synthesizes the final answer. Best for complex multi-step tasks with dynamic decomposition.
+
+**Template ID:** `ai-orchestration-orchestrator-worker`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** ai-orchestration  
+**Complexity:** 3/5  
+**Nodes:** 15  
+**Lanes:** 5  
+**Tags:** [ai-native, orchestrator-worker, conductor, multi-agent, architecture-diagram, orchestration]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/ai-orchestration-orchestrator-worker`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/ai-orchestration-orchestrator-worker/metadata.json

@@ -0,0 +1,29 @@
+{
+  "template_id": "ai-orchestration-orchestrator-worker",
+  "workflow_id": "ai-orchestration-orchestrator-worker",
+  "title": "AI Orchestration - Orchestrator-Worker",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [
+    "ai-orchestration"
+  ],
+  "use_cases": [
+    "agentic",
+    "ai-orchestration"
+  ],
+  "complexity": 3,
+  "num_nodes": 15,
+  "num_lanes": 5,
+  "tags": [
+    "ai-native",
+    "orchestrator-worker",
+    "conductor",
+    "multi-agent",
+    "architecture-diagram",
+    "orchestration"
+  ],
+  "description": "A conductor-style architecture where one orchestrator agent receives a complex task, breaks it into subtasks, dispatches each to specialist worker agents (research, code, review), collects results, and synthesizes the final answer. Best for complex multi-step tasks with dynamic decomposition.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/ai-orchestration-orchestrator-worker"
+}

agentic/architecture/ai-orchestration-orchestrator-worker/workflow.fz

@@ -0,0 +1,44 @@
+User { # User
+  n1: circle label="Start"
+  n2: rectangle label="Submit complex task"
+  n1.handle(right) -> n2.handle(left)
+  n2.handle(bottom) -> Orchestrator.n3.handle(top) [label="Task"]
+}
+
+Orchestrator { # Orchestrator Agent
+  n3: rectangle label="Receive task"
+  n4: rectangle label="Break into subtasks"
+  n5: rectangle label="Dispatch subtasks"
+  n6: rectangle label="Collect results"
+  n7: rectangle label="Synthesize final answer"
+  n8: circle label="Done"
+  n3.handle(right) -> n4.handle(left)
+  n4.handle(right) -> n5.handle(left)
+  n5.handle(bottom) -> Research.n9.handle(top) [label="Research subtask"]
+  n5.handle(bottom) -> Code.n11.handle(top) [label="Code subtask"]
+  n5.handle(bottom) -> Review.n13.handle(top) [label="Review subtask"]
+  n6.handle(right) -> n7.handle(left)
+  n7.handle(right) -> n8.handle(left)
+  n7.handle(top) -> User.n2.handle(bottom) [label="Response"]
+}
+
+Research { # Research Agent
+  n9: rectangle label="Search sources"
+  n10: rectangle label="Summarize findings"
+  n9.handle(right) -> n10.handle(left)
+  n10.handle(top) -> Orchestrator.n6.handle(bottom) [label="Research result"]
+}
+
+Code { # Code Agent
+  n11: rectangle label="Generate code"
+  n12: rectangle label="Run tests"
+  n11.handle(right) -> n12.handle(left)
+  n12.handle(top) -> Orchestrator.n6.handle(bottom) [label="Code result"]
+}
+
+Review { # Review Agent
+  n13: rectangle label="Evaluate quality"
+  n14: rectangle label="Flag issues"
+  n13.handle(right) -> n14.handle(left)
+  n14.handle(top) -> Orchestrator.n6.handle(bottom) [label="Review result"]
+}

agentic/architecture/ai-orchestration-parallel-fan-out/README.md

@@ -0,0 +1,19 @@
+# AI Orchestration - Parallel Fan-Out (Map-Reduce)
+
+A map-reduce style architecture where a coordinator fans out tasks to multiple parallel worker agents (style check, security audit, performance analysis), gathers all results, and makes an aggregate decision. Best for PR reviews, code reviews, and multi-dimensional analysis.
+
+**Template ID:** `ai-orchestration-parallel-fan-out`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** ai-orchestration  
+**Complexity:** 3/5  
+**Nodes:** 9  
+**Lanes:** 3  
+**Tags:** [ai-native, parallel-fan-out, map-reduce, coordinator, multi-agent, architecture-diagram, orchestration]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/ai-orchestration-parallel-fan-out`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/ai-orchestration-parallel-fan-out/metadata.json

@@ -0,0 +1,30 @@
+{
+  "template_id": "ai-orchestration-parallel-fan-out",
+  "workflow_id": "ai-orchestration-parallel-fan-out",
+  "title": "AI Orchestration - Parallel Fan-Out (Map-Reduce)",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [
+    "ai-orchestration"
+  ],
+  "use_cases": [
+    "agentic",
+    "ai-orchestration"
+  ],
+  "complexity": 3,
+  "num_nodes": 9,
+  "num_lanes": 3,
+  "tags": [
+    "ai-native",
+    "parallel-fan-out",
+    "map-reduce",
+    "coordinator",
+    "multi-agent",
+    "architecture-diagram",
+    "orchestration"
+  ],
+  "description": "A map-reduce style architecture where a coordinator fans out tasks to multiple parallel worker agents (style check, security audit, performance analysis), gathers all results, and makes an aggregate decision. Best for PR reviews, code reviews, and multi-dimensional analysis.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/ai-orchestration-parallel-fan-out"
+}

agentic/architecture/ai-orchestration-parallel-fan-out/workflow.fz

@@ -0,0 +1,31 @@
+Trigger { # Trigger
+  n1: circle label="Start"
+  n2: rectangle label="PR submitted for review"
+  n1.handle(right) -> n2.handle(left)
+  n2.handle(bottom) -> Coordinator.n3.handle(top) [label="PR payload"]
+}
+
+Coordinator { # Coordinator Agent
+  n3: rectangle label="Fan out to reviewers"
+  n4: rectangle label="Gather all reviews"
+  n5: diamond label="All passed?"
+  n6: rectangle label="Approve PR"
+  n7: rectangle label="Request changes"
+  n8: circle label="Done"
+  n3.handle(bottom) -> Reviewers.n9.handle(top) [label="Style check"]
+  n3.handle(bottom) -> Reviewers.n10.handle(top) [label="Security audit"]
+  n3.handle(bottom) -> Reviewers.n11.handle(top) [label="Perf analysis"]
+  n4.handle(right) -> n5.handle(left)
+  n5.handle(right) -> n6.handle(left) [label="Yes"]
+  n5.handle(bottom) -> n7.handle(top) [label="No"]
+  n6.handle(right) -> n8.handle(left)
+}
+
+Reviewers { # Parallel Review Agents
+  n9: rectangle label="Style Agent"
+  n10: rectangle label="Security Agent"
+  n11: rectangle label="Performance Agent"
+  n9.handle(top) -> Coordinator.n4.handle(bottom) [label="Style report"]
+  n10.handle(top) -> Coordinator.n4.handle(bottom) [label="Security report"]
+  n11.handle(top) -> Coordinator.n4.handle(bottom) [label="Perf report"]
+}

agentic/architecture/context-shared-memory/README.md

@@ -0,0 +1,19 @@
+# Context Management - Shared Memory
+
+Multi-agent coordination pattern where an orchestrator breaks work into subtasks, specialist agents pull from and push to a shared state store, and the orchestrator composes the final answer from that shared state. Multi-agent setups feel coherent instead of each assistant having its own inconsistent memory.
+
+**Template ID:** `context-shared-memory`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** agentic  
+**Secondary use cases:** context-management  
+**Complexity:** 3/5  
+**Nodes:** 9  
+**Lanes:** 4  
+**Tags:** [context-management, shared-memory, multi-agent, orchestrator, architecture-diagram]  
+**Source path:** ``  
+**Repo path:** `agentic/architecture/context-shared-memory`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/architecture/context-shared-memory/metadata.json

@@ -0,0 +1,28 @@
+{
+  "template_id": "context-shared-memory",
+  "workflow_id": "context-shared-memory",
+  "title": "Context Management - Shared Memory",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [
+    "context-management"
+  ],
+  "use_cases": [
+    "agentic",
+    "context-management"
+  ],
+  "complexity": 3,
+  "num_nodes": 9,
+  "num_lanes": 4,
+  "tags": [
+    "context-management",
+    "shared-memory",
+    "multi-agent",
+    "orchestrator",
+    "architecture-diagram"
+  ],
+  "description": "Multi-agent coordination pattern where an orchestrator breaks work into subtasks, specialist agents pull from and push to a shared state store, and the orchestrator composes the final answer from that shared state. Multi-agent setups feel coherent instead of each assistant having its own inconsistent memory.",
+  "source_path": "",
+  "repo_path": "agentic/architecture/context-shared-memory"
+}

agentic/architecture/context-shared-memory/workflow.fz

@@ -0,0 +1,46 @@
+Orchestrator {
+  n1: circle label="Complex task arrives"
+  n2: rectangle label="Request shared context"
+  n3: rectangle label="Create research subtask"
+  n4: rectangle label="Create action subtask"
+  n5: rectangle label="Receive findings and results"
+  n6: rectangle label="Compile final answer"
+  n1.handle(right) -> n2.handle(left)
+  n2.handle(bottom) -> SharedMemory.n7.handle(top) [label="Read state"]
+  n3.handle(right) -> n4.handle(left)
+  n3.handle(bottom) -> Researcher.n9.handle(top) [label="Research task"]
+  n4.handle(bottom) -> Operator.n13.handle(top) [label="Action task"]
+  n5.handle(right) -> n6.handle(left)
+  Researcher.n12.handle(top) -> n5.handle(left) [label="Finding"]
+  Operator.n17.handle(top) -> n5.handle(right) [label="Result"]
+}
+
+Researcher {
+  n9: rectangle label="Receive research task"
+  n10: rectangle label="Read shared memory"
+  n11: rectangle label="Analyze with context"
+  n12: rectangle label="Return finding"
+  n9.handle(right) -> n10.handle(left)
+  n10.handle(right) -> n11.handle(left)
+  n11.handle(right) -> n12.handle(left)
+  n10.handle(bottom) -> SharedMemory.n7.handle(left) [label="Read state"]
+}
+
+Operator {
+  n13: rectangle label="Receive action task"
+  n14: rectangle label="Read shared memory"
+  n15: rectangle label="Execute with context"
+  n16: rectangle label="Write result to memory"
+  n17: rectangle label="Return result"
+  n13.handle(right) -> n14.handle(left)
+  n14.handle(right) -> n15.handle(left)
+  n15.handle(right) -> n16.handle(left)
+  n16.handle(bottom) -> SharedMemory.n8.handle(left) [label="Write state"]
+  n15.handle(bottom) -> n17.handle(top)
+}
+
+SharedMemory {
+  n7: rectangle label="Resolve memory request"
+  n8: rectangle label="Update shared state"
+  n7.handle(right) -> n8.handle(left)
+}

agentic/devops/mcp-agent-mesh/README.md

@@ -0,0 +1,19 @@
+# MCP Agent Mesh Architecture
+
+A multi-agent mesh pattern where agents communicate through a shared context broker backed by MCP. Enables coordinated tool access and state synchronization across multiple specialized agents (planner, coder, reviewer, operator). Supports both orchestrated and choreographed interaction patterns.
+
+**Template ID:** `mcp-agent-mesh`  
+**Kind:** architecture  
+**Source domain:** DevOps  
+**Primary use case:** agentic  
+**Secondary use cases:** mcp  
+**Complexity:** 4/5  
+**Nodes:** 10  
+**Lanes:** 4  
+**Tags:** [mcp, agent-mesh, shared-context, multi-agent, broker, architecture-diagram, production-grade]  
+**Source path:** ``  
+**Repo path:** `agentic/devops/mcp-agent-mesh`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

agentic/devops/mcp-agent-mesh/metadata.json

@@ -0,0 +1,30 @@
+{
+  "template_id": "mcp-agent-mesh",
+  "workflow_id": "mcp-agent-mesh",
+  "title": "MCP Agent Mesh Architecture",
+  "kind": "architecture",
+  "source_domain": "DevOps",
+  "primary_use_case": "agentic",
+  "secondary_use_cases": [
+    "mcp"
+  ],
+  "use_cases": [
+    "agentic",
+    "mcp"
+  ],
+  "complexity": 4,
+  "num_nodes": 10,
+  "num_lanes": 4,
+  "tags": [
+    "mcp",
+    "agent-mesh",
+    "shared-context",
+    "multi-agent",
+    "broker",
+    "architecture-diagram",
+    "production-grade"
+  ],
+  "description": "A multi-agent mesh pattern where agents communicate through a shared context broker backed by MCP. Enables coordinated tool access and state synchronization across multiple specialized agents (planner, coder, reviewer, operator). Supports both orchestrated and choreographed interaction patterns.",
+  "source_path": "",
+  "repo_path": "agentic/devops/mcp-agent-mesh"
+}

agentic/devops/mcp-agent-mesh/workflow.fz

@@ -0,0 +1,41 @@
+Orchestrator { # Orchestrator Agent
+  n1: circle label="Complex task received"
+  n2: rectangle label="Decompose into subtasks"
+  n3: rectangle label="Assign subtask to Agent B"
+  n4: rectangle label="Receive subtask result"
+  n5: rectangle label="Request shared context"
+  n6: rectangle label="Compile final response"
+  n1.handle(right) -> n2.handle(left)
+  n2.handle(right) -> n3.handle(left)
+  n3.handle(bottom) -> Worker.n7.handle(top) [label="Subtask assignment"]
+  n4.handle(right) -> n5.handle(left)
+  n5.handle(bottom) -> Broker.n11.handle(top) [label="Context request"]
+  n6.handle(left) -> n2.handle(bottom) [label="Next iteration"]
+}
+
+Worker { # Worker Agent
+  n7: rectangle label="Receive subtask"
+  n8: rectangle label="Fetch shared context"
+  n9: rectangle label="Call MCP tool"
+  n10: rectangle label="Return result to orchestrator"
+  n7.handle(right) -> n8.handle(left)
+  n8.handle(bottom) -> Broker.n11.handle(left) [label="Context request"]
+  n8.handle(right) -> n9.handle(left)
+  n9.handle(bottom) -> MCPServer.n13.handle(top) [label="MCP tool call"]
+  n10.handle(top) -> Orchestrator.n4.handle(bottom) [label="Subtask result"]
+}
+
+Broker { # Shared Context Broker
+  n11: rectangle label="Resolve context request"
+  n12: rectangle label="Return shared state"
+  n11.handle(right) -> n12.handle(left)
+  n12.handle(top) -> Orchestrator.n6.handle(bottom) [label="Context to orchestrator"]
+  n12.handle(left) -> Worker.n9.handle(top) [label="Context to worker"]
+}
+
+MCPServer { # MCP Server
+  n13: rectangle label="Execute tool"
+  n14: rectangle label="Return tool output"
+  n13.handle(right) -> n14.handle(left)
+  n14.handle(top) -> Worker.n10.handle(bottom) [label="Tool output"]
+}

ai-orchestration/architecture/ai-orchestration-event-driven-mesh/README.md

@@ -0,0 +1,19 @@
+# AI Orchestration - Event-Driven Mesh (Kafka-First)
+
+An event-driven agent mesh architecture using a Kafka-style event broker. Multiple agents subscribe to topics (orders, alerts, analytics), process events independently, and publish results back to the bus. Best for real-time event processing and decoupled service architectures.
+
+**Template ID:** `ai-orchestration-event-driven-mesh`  
+**Kind:** architecture  
+**Source domain:** Architecture  
+**Primary use case:** ai-orchestration  
+**Secondary use cases:** mcp  
+**Complexity:** 3/5  
+**Nodes:** 13  
+**Lanes:** 5  
+**Tags:** [ai-native, event-driven, kafka, agent-mesh, pub-sub, architecture-diagram, orchestration]  
+**Source path:** ``  
+**Repo path:** `ai-orchestration/architecture/ai-orchestration-event-driven-mesh`
+
+## Files
+- `workflow.fz` — FlowZap Code source
+- `metadata.json` — Structured metadata

ai-orchestration/architecture/ai-orchestration-event-driven-mesh/metadata.json

@@ -0,0 +1,30 @@
+{
+  "template_id": "ai-orchestration-event-driven-mesh",
+  "workflow_id": "ai-orchestration-event-driven-mesh",
+  "title": "AI Orchestration - Event-Driven Mesh (Kafka-First)",
+  "kind": "architecture",
+  "source_domain": "Architecture",
+  "primary_use_case": "ai-orchestration",
+  "secondary_use_cases": [
+    "mcp"
+  ],
+  "use_cases": [
+    "ai-orchestration",
+    "mcp"
+  ],
+  "complexity": 3,
+  "num_nodes": 13,
+  "num_lanes": 5,
+  "tags": [
+    "ai-native",
+    "event-driven",
+    "kafka",
+    "agent-mesh",
+    "pub-sub",
+    "architecture-diagram",
+    "orchestration"
+  ],
+  "description": "An event-driven agent mesh architecture using a Kafka-style event broker. Multiple agents subscribe to topics (orders, alerts, analytics), process events independently, and publish results back to the bus. Best for real-time event processing and decoupled service architectures.",
+  "source_path": "",
+  "repo_path": "ai-orchestration/architecture/ai-orchestration-event-driven-mesh"
+}

ai-orchestration/architecture/ai-orchestration-event-driven-mesh/workflow.fz

@@ -0,0 +1,39 @@
+Source { # Event Sources
+  n1: circle label="Start"
+  n2: rectangle label="User action event"
+  n3: rectangle label="System alert event"
+  n1.handle(right) -> n2.handle(left)
+  n2.handle(bottom) -> Broker.n4.handle(top) [label="Publish event"]
+  n3.handle(bottom) -> Broker.n4.handle(top) [label="Publish event"]
+}
+
+Broker { # Event Broker (Kafka / Pub-Sub)
+  n4: rectangle label="Event bus receives event"
+  n5: rectangle label="Route to subscribers"
+  n4.handle(right) -> n5.handle(left)
+  n5.handle(bottom) -> Orders.n6.handle(top) [label="topic: orders"]
+  n5.handle(bottom) -> Alerts.n8.handle(top) [label="topic: alerts"]
+  n5.handle(bottom) -> Analytics.n10.handle(top) [label="topic: analytics"]
+}
+
+Orders { # Order Processing Agent
+  n6: rectangle label="Parse order event"
+  n7: rectangle label="Execute fulfillment"
+  n6.handle(right) -> n7.handle(left)
+  n7.handle(bottom) -> Broker.n4.handle(top) [label="Publish: order.completed"]
+}
+
+Alerts { # Alert Triage Agent
+  n8: rectangle label="Classify severity"
+  n9: rectangle label="Route to on-call or auto-resolve"
+  n8.handle(right) -> n9.handle(left)
+  n9.handle(bottom) -> Broker.n4.handle(top) [label="Publish: alert.resolved"]
+}
+
+Analytics { # Analytics Agent
+  n10: rectangle label="Aggregate metrics"
+  n11: rectangle label="Update dashboard"
+  n12: circle label="Stored"
+  n10.handle(right) -> n11.handle(left)
+  n11.handle(right) -> n12.handle(left)
+}