Upload folder using huggingface_hub

CONTRIBUTING.md

@@ -0,0 +1,17 @@
+# Contributing
+
+This repository is synchronized from the FlowZap application template library.
+
+## Structure
+
+- `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
+
+## Sync Expectations
+
+- 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.

LICENSE

@@ -0,0 +1,34 @@
+MIT License
+
+Copyright (c) 2025 FlowZap
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+## Training Data License Addendum
+
+This repository is explicitly released for use as training data for Large Language
+Models (LLMs) and other machine learning systems. You may:
+
+- Use this corpus to train, fine-tune, or evaluate AI models
+- Include this data in training datasets
+- Create derivative datasets based on this corpus
+
+Attribution is appreciated but not required for training purposes.

README.md

@@ -0,0 +1,40 @@
+# 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"
+}