chore: import upstream snapshot with attribution

apps/sim/lib/compare/data/competitors/flowise.ts

@@ -0,0 +1,951 @@
+import { FlowiseIcon } from '@/components/icons'
+import type { CompetitorProfile } from '@/lib/compare/data/types'
+
+/** Researched and cross-verified against live vendor sources on 2026-07-02. */
+export const flowiseProfile: CompetitorProfile = {
+  id: 'flowise',
+  name: 'Flowise',
+  website: 'https://flowiseai.com',
+  brand: {
+    icon: FlowiseIcon,
+    selfFramed: true,
+    colors: ['#5D5DFF', '#1F1F2E'],
+    source: 'GitHub organization avatar',
+    asOf: '2026-07-02',
+  },
+  oneLiner:
+    'Flowise is an open-source, low-code visual builder for LLM chains, RAG pipelines, and multi-agent AI workflows, available self-hosted or as a managed cloud service, and owned by Workday since August 2025.',
+  standoutFeatures: [
+    {
+      title: 'Choice of vector-store backend, with the broadest native text-splitter menu',
+      description:
+        "Flowise's Document Store lets a builder pick from a wide range of vector store backends to upsert into (Pinecone, Weaviate, Milvus, FAISS, and more), and offers the broadest range of native text-splitter types (character, token, recursive character, markdown, code, HTML-to-markdown) with configurable chunk size and overlap, a live preview before processing, and per-chunk editing.",
+      shortDescription:
+        'Pick your own vector-store backend, with the broadest built-in text-splitter menu.',
+      source: {
+        url: 'https://docs.flowiseai.com/using-flowise/document-stores',
+        label: 'Flowise Docs: Document Stores',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'Built-in dataset-based batch evaluation',
+      description:
+        "Flowise ships an Evaluations feature, available on Flowise Cloud/Enterprise plans (not the open-source self-hosted product), that runs chatflows/agentflows against a saved dataset in one batch, scoring outputs with string, numeric, or LLM-as-judge evaluators and reporting pass/fail rate, average tokens, and latency across the whole run. Sim's own Evaluator block scores individual calls against user-defined metrics, but has no equivalent golden-dataset batch runner. (Flowise's Agentflow V2 also has a Human Input node for pausing on approve/reject feedback, comparable to Sim's own human-in-the-loop approval block.)",
+      shortDescription:
+        'Built-in dataset-based batch evaluation (Cloud/Enterprise plans) with LLM-judge scoring and pass/fail reporting.',
+      source: {
+        url: 'https://docs.flowiseai.com/using-flowise/evaluations',
+        label: 'Flowise Docs: Evaluations',
+        asOf: '2026-07-08',
+      },
+    },
+    {
+      title: 'Larger existing open-source community, on the same Apache 2.0 license as Sim',
+      description:
+        'Both Flowise and Sim are Apache License 2.0 and self-hostable, so the license itself is not a differentiator. Where Flowise stands out is community scale: its GitHub repo has roughly 54,000 stars and an active Discord community built up since 2023.',
+      shortDescription:
+        'Same Apache 2.0 license as Sim, but a larger existing community: ~54k GitHub stars, active Discord.',
+      source: {
+        url: 'https://github.com/FlowiseAI/Flowise',
+        label: 'GitHub: FlowiseAI/Flowise',
+        asOf: '2026-07-02',
+      },
+    },
+  ],
+  limitations: [
+    {
+      title: 'Low enterprise-readiness score in third-party benchmarking',
+      description:
+        'The n8n 2026 AI Agent Development Tools report scored Flowise at 37% on "Enterpriseness," versus 63% on "Codability," citing gaps in security features, authentication mechanisms, and production-grade governance compared to top-performing platforms.',
+      shortDescription:
+        'Scored only 37% on enterprise-readiness in a third-party 2026 vendor report.',
+      source: {
+        url: 'https://n8n.io/reports/2026-ai-agent-development-tools/#vendors',
+        label: 'n8n: 2026 AI Agent Development Tools report',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'No native real-time multiplayer canvas editing',
+      description:
+        "Flowise's core canvas supports only one user editing a flow at a time, with no built-in real-time co-editing of the same chatflow. A related multi-user/collaboration feature request (GitHub issue #2661) was closed as not planned.",
+      shortDescription: 'No live multi-cursor concurrent editing of the same flow.',
+      source: {
+        url: 'https://github.com/FlowiseAI/Flowise/issues/2661',
+        label: 'GitHub Issue #2661: Multi User Support (closed, not planned)',
+        asOf: '2026-07-08',
+      },
+    },
+  ],
+  facts: {
+    platform: {
+      builderType: {
+        value:
+          'Flowise is primarily a drag-and-drop visual canvas for wiring chatflow and agentflow nodes together, supplemented by Custom JS Function nodes for arbitrary code and a Custom Tool node for JS-based tools. There is no natural-language "describe it and I\'ll build it" flow generator.',
+        detail: 'No natural-language workflow generation feature.',
+        shortValue: 'Visual canvas plus custom-code nodes',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/integrations/utilities/custom-js-function',
+            label: 'Flowise Docs: Custom JS Function',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      learningCurve: {
+        value:
+          'Approachable for non-technical users via templates and drag-and-drop nodes, but real production use (custom tools, external libraries, env vars) requires developer comfort with JavaScript and LangChain concepts.',
+        shortValue: 'Easy to start, technical depth needed for production',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/integrations/utilities/custom-js-function',
+            label: 'Flowise Docs: Custom JS Function',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      selfHostOption: {
+        value:
+          "Yes: Flowise's Community Edition is Apache 2.0 and can be self-hosted, including via Docker, on your own infrastructure.",
+        shortValue: 'Yes, self-hostable via Docker',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://github.com/FlowiseAI/Flowise/blob/main/LICENSE.md',
+            label: 'GitHub: Flowise LICENSE.md',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      deploymentOptions: {
+        value:
+          'Flowise offers self-hosted open-source deployment (Docker/npm), a managed multi-tenant Cloud plan, and an Enterprise tier supporting on-premise or air-gapped deployment for regulated industries.',
+        shortValue: 'Self-hosted, cloud, and enterprise on-prem/air-gapped',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://www.lindy.ai/blog/flowise-pricing',
+            label: 'Lindy: Flowise Pricing, Features, and Alternatives for 2026',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/workspaces',
+            label: 'Flowise Docs: Workspaces',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      templates: {
+        value:
+          'Yes: Flowise ships a Marketplace of pre-built, production-ready chatflow and agentflow templates (document Q&A/RAG, SQL agents, multi-agent orchestration), filterable by type, framework, and use case, plus support for organizations to save their own custom templates.',
+        shortValue: 'Yes, built-in marketplace of chatflow/agentflow templates',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://deepwiki.com/FlowiseAI/Flowise/11.1-marketplace-and-template-flows',
+            label: 'DeepWiki: Marketplace & Template Flows',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      license: {
+        value:
+          "Flowise's Community Edition is licensed under the Apache License, Version 2.0. Paid-tier-only modules ship under a separate Commercial License: RBAC, audit/login-activity logs, and organization workspaces are available on both the Cloud and Enterprise plans, while SSO is restricted to the Enterprise plan only.",
+        shortValue: 'Apache 2.0 (core); RBAC/audit on Cloud+Enterprise, SSO Enterprise-only',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://github.com/FlowiseAI/Flowise/blob/main/LICENSE.md',
+            label: 'GitHub: Flowise LICENSE.md',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/workspaces',
+            label: 'Flowise Docs: Workspaces',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://docs.flowiseai.com/configuration/sso',
+            label: 'Flowise Docs: SSO',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
+      environmentPromotion: {
+        value:
+          "Unknown: no documentation describes forking or cloning a whole project or workspace and promoting it between dev, QA, and production environments. Flowise's version control works at the level of individual chatflow/assistant history snapshots, not whole-environment promotion.",
+        shortValue: 'Unknown / not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      versionControlDepth: {
+        value:
+          'Yes: Flowise automatically saves a version snapshot every time you save a ChatFlow or Assistant, with a history view to restore prior versions. This is snapshot-and-restore depth, not full diff or branching.',
+        shortValue: 'Snapshot history with restore, no diff/branching shown',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://github.com/FlowiseAI/Flowise/pull/5024',
+            label: 'GitHub PR #5024: Implement version control system for ChatFlows and Assistants',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      realtimeCollaboration: {
+        value:
+          "No: Flowise's canvas supports only one user per session, with no live, multi-cursor editing of the same flow. Cloud/Enterprise multi-user features (workspaces, RBAC) govern access, not concurrent editing.",
+        detail:
+          'No public Flowise GitHub issue specifically tracks multi-cursor/real-time canvas collaboration as a feature request; GitHub issue #2661, sometimes cited for this, is actually a closed request about user authentication, RBAC, and audit trails, not concurrent editing.',
+        shortValue: 'No live multi-user concurrent canvas editing',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/workspaces',
+            label: 'Flowise Docs: Workspaces',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
+      nativeFileStorage: {
+        value:
+          "Unknown: no documented general-purpose file storage system with folder hierarchy, link-sharing with access controls, or recovery of deleted items. Flowise's file handling is scoped to per-node uploads and Document Store ingestion, not a standalone file manager.",
+        shortValue: 'Unknown, only per-node file uploads documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      dataTables: {
+        value:
+          "Unknown: no native spreadsheet-like data table feature with row/column limits and keyboard navigation is documented. Flowise's structured-data support comes through external database and vector-store connector nodes instead.",
+        shortValue: 'Unknown, not documented as a native feature',
+        confidence: 'unknown',
+        sources: [],
+      },
+      richTextEditor: {
+        value:
+          'Unknown: no documented inline rich-text/WYSIWYG markdown editor for documents stored in Flowise.',
+        shortValue: 'Unknown, not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      subWorkflows: {
+        value:
+          "Yes: Flowise's Execute Flow node calls another saved Chatflow or Agentflow as a step, passes it input, waits for the child flow to finish, and receives its output back to continue the parent flow.",
+        shortValue: 'Yes, via the Execute Flow node',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/agentflowv2',
+            label: 'Flowise Docs: Agentflow V2 (Execute Flow node)',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      customBlocks: {
+        value:
+          "No: Flowise has no feature for publishing a deployed chatflow/agentflow as a named, encapsulated block that appears in the node palette for other users across an organization. Its closest feature, the Execute Flow node, only lets a flow call another saved flow by name or ID from within the same Flowise instance, passing input and receiving output; the docs describe this as invoking an existing flow, not publishing a version-synced, credential-hidden component into a shared toolbar. Flowise's Custom Tool node is likewise scoped to inline JavaScript written within a single flow, not a published workflow-as-block. There is no documented mechanism that hides a source flow's internal steps/credentials from consumers, restricts a published block via access control/permission groups, or automatically points every consumer at the source flow's latest deployed version.",
+        detail:
+          "This is distinct from Flowise's Execute Flow sub-workflow calling (see subWorkflows above), which is same-instance flow-to-flow composition, not org-wide reuse of a hidden, centrally-updated block by other users.",
+        shortValue: 'No, only same-instance Execute Flow calls; no published org-wide block',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/agentflowv2',
+            label: 'Flowise Docs: Agentflow V2 (Execute Flow node)',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://docs.flowiseai.com/integrations/langchain/tools/custom-tool',
+            label: 'Flowise Docs: Custom Tool',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
+    },
+    aiCapabilities: {
+      multiLlmSupport: {
+        value:
+          'Yes: Flowise integrates a broad set of LLM providers including OpenAI, Azure OpenAI, AWS Bedrock, Google Vertex AI, Cohere, HuggingFace Inference, Ollama, and Replicate, plus (via its separate Chat Models integrations, e.g. ChatAnthropic) Anthropic Claude models, covering both hosted and self-hosted open-source models.',
+        shortValue: 'Broad support: OpenAI, Azure, Bedrock, Google, Anthropic, Ollama, more',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/integrations/langchain/llms',
+            label: 'Flowise Docs: LLMs',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.flowiseai.com/integrations/langchain/chat-models',
+            label: 'Flowise Docs: Chat Models (incl. ChatAnthropic)',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
+      agentReasoningBlocks: {
+        value:
+          "Yes: Flowise's Agentflow V2 provides dedicated Agent nodes plus orchestration primitives (Condition, Iteration, Human Input) for multi-step agent reasoning and tool-use loops, distinct from plain data-routing nodes.",
+        shortValue: 'Yes, dedicated Agent/Condition/Iteration nodes in Agentflow V2',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/agentflowv2',
+            label: 'Flowise Docs: Agentflow V2',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      naturalLanguageBuilding: {
+        value:
+          'No: no documented feature lets a user describe an automation in plain language and have Flowise generate or edit the flow automatically. Flowise is primarily a drag-and-drop visual canvas, supplemented by Custom JS Function nodes for arbitrary code, with no natural-language "describe it and I\'ll build it" flow generator.',
+        shortValue: 'No, not documented as a feature',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/integrations/utilities/custom-js-function',
+            label: 'Flowise Docs: Custom JS Function',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      knowledgeBaseRag: {
+        value:
+          "Yes: Flowise's Document Store provides a full RAG pipeline covering document loading (PDF, web pages, Word, etc.), configurable chunking/text-splitting, multiple embedding providers, and upsert into vector stores like Pinecone, Weaviate, Milvus, and FAISS.",
+        detail:
+          "n8n's 2026 report rated Flowise's chunking/splitter options the broadest natively available among evaluated tools.",
+        shortValue: 'Yes, full built-in Document Store RAG pipeline',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/document-stores',
+            label: 'Flowise Docs: Document Stores',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://n8n.io/reports/2026-ai-agent-development-tools/#vendors',
+            label: 'n8n: 2026 AI Agent Development Tools report',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      mcpSupport: {
+        value:
+          'Yes: Flowise acts as an MCP client, consuming external MCP servers as tools via Stdio (NPX/Docker) or Streamable HTTP transports, with prebuilt MCP integrations (GitHub, Atlassian Jira, Brave Search) and a Custom MCP node for any server.',
+        shortValue: 'Yes, MCP client consuming external servers as tools',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/tutorials/tools-and-mcp',
+            label: 'Flowise Docs: Tools & MCP',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      evaluationGuardrails: {
+        value:
+          'Yes: Flowise has a built-in Evaluations feature that runs datasets through chatflows/agentflows and scores outputs with string-match, numeric, or LLM-as-judge evaluators, reporting pass/fail rate, average tokens consumed, and latency. There is no separate, dedicated "guardrail validation" block beyond this.',
+        shortValue: 'Yes, built-in dataset-based evaluation with LLM-judge scoring',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/evaluations',
+            label: 'Flowise Docs: Evaluations',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      humanInTheLoop: {
+        value:
+          'Yes: Agentflow V2 includes a dedicated Human Input node that pauses execution and resumes only after a human approves or rejects the pending action, with separate output paths for each outcome.',
+        shortValue: 'Yes, dedicated Human Input approve/reject node',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/tutorials/human-in-the-loop',
+            label: 'Flowise Docs: Human In The Loop',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      generativeMedia: {
+        value:
+          'Partial: Flowise supports speech-to-text nodes and multi-modal image inputs. Image and audio generation can be wired in via custom tools calling providers like Replicate (Stable Diffusion) or ElevenLabs, but the standard node library has no dedicated, built-in image, video, or text-to-speech generation node.',
+        detail:
+          'Community GitHub issues show text-to-speech and native image generation as requested but not shipped as first-class nodes.',
+        shortValue: 'Partial: STT built in, image/TTS via custom tools only',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://github.com/FlowiseAI/Flowise/issues/2385',
+            label: 'GitHub Issue #2385: Text To Speech',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      dynamicToolUse: {
+        value:
+          "Yes: Flowise's Agent nodes and Custom MCP integration let an agent dynamically discover and select from a connected pool of tools/actions at inference time, rather than calling only a single pre-wired tool per step.",
+        shortValue: 'Yes, agents can dynamically pick from connected tools/MCP servers',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/tutorials/tools-and-mcp',
+            label: 'Flowise Docs: Tools & MCP',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      modelFallback: {
+        value:
+          'Unknown: no documented automatic retry against a different model or provider on a failed/rate-limited LLM call.',
+        shortValue: 'Unknown, not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      agentSkills: {
+        value:
+          'Unknown: no documented reusable, named prompt/knowledge-snippet feature invoked by reference across multiple agents, distinct from a one-off system prompt or Variables feature.',
+        detail:
+          'Flowise has a general Variables feature (static/runtime key-value), but it is not documented as an agent-skill abstraction.',
+        shortValue: 'Unknown, not documented as a distinct feature',
+        confidence: 'unknown',
+        sources: [],
+      },
+      nativeChatDeployment: {
+        value:
+          'Yes: a built flow can be deployed as a shareable public chat URL or an embeddable chat widget (popup bubble or full-page, via JS script or React components), plus a REST API endpoint.',
+        shortValue: 'Yes, public chat URL and embeddable widget deployment',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/embed',
+            label: 'Flowise Docs: Embed',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      kbChunkVisibility: {
+        value:
+          'Yes: Flowise\'s Document Store lets users preview and edit individual chunks after ingestion (n8n\'s report calls this "post-processing"). Retrieval and upsertion views show chunk-level detail, not just whole-document results.',
+        shortValue: 'Yes, per-chunk preview and editing in Document Store',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://n8n.io/reports/2026-ai-agent-development-tools/#vendors',
+            label: 'n8n: 2026 AI Agent Development Tools report',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/upsertion',
+            label: 'Flowise Docs: Upsertion',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      parallelExecution: {
+        value:
+          "No: AgentFlow V2 lets users draw a branching canvas layout, but the execution engine processes the queue one node at a time and does not run parallel branches concurrently, per user reports and Flowise's own issue tracker. This causes chat-history and input-inheritance bugs when a canvas is arranged in a parallel shape.",
+        shortValue: 'No, branches in AgentFlow V2 execute sequentially, not concurrently',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://github.com/FlowiseAI/Flowise/issues/4673',
+            label: 'Flowise GitHub: "Not working parallel Node in AgentFlow 2" (#4673)',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://github.com/FlowiseAI/Flowise/issues/4710',
+            label:
+              'Flowise GitHub: "Parallel Node Execution is causing State Contamination" (#4710)',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/agentflowv2',
+            label: 'Flowise Docs: Agentflow V2',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      a2aProtocol: {
+        value:
+          'No: Google A2A (Agent2Agent) protocol support is an open, unimplemented GitHub feature request (opened April 2025). Flowise supports MCP for tool-calling but has no Agent Card or agent-to-agent discovery feature.',
+        shortValue: 'No, A2A support is an open feature request, not implemented',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://github.com/FlowiseAI/Flowise/issues/4283',
+            label: 'Flowise GitHub: "Support the Google A2A (Agent2Agent) Protocol" (#4283, open)',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      loopIteration: {
+        value:
+          "Yes: Flowise's Agentflow V2 has a dedicated Iteration node that takes an array and executes a nested sub-flow of steps once per item, running sequentially. Its separate Loop node instead jumps backward to re-run an earlier node, a retry cycle rather than a collection iterator.",
+        shortValue: 'Yes, via the Iteration node (separate Loop node is retry-only)',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/agentflowv2',
+            label: 'Flowise Docs: Agentflow V2 (Iteration and Loop nodes)',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    integrations: {
+      integrationCount: {
+        value:
+          'Flowise documents integration categories across LLMs, vector stores, document loaders, embeddings, tools, and MCP servers (referred to internally as "nodes"), but publishes no exact total node/integration count.',
+        shortValue: 'Broad multi-category node library, exact count unverified',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/integrations',
+            label: 'Flowise Docs: Integrations',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      triggerTypes: {
+        value:
+          'Flowise flows are triggered via the chat widget or public URL, direct REST API prediction calls (/api/v1/prediction/{chatflowId}), and Custom MCP/tool invocations. There is no dedicated cron/schedule trigger or broad library of app-specific event triggers.',
+        shortValue: 'Chat, API/webhook-style prediction calls; no schedule trigger found',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://agentsapis.com/flowise-api/',
+            label: 'Flowise API: Complete Developer Guide',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      customCodeSteps: {
+        value:
+          'Yes: Flowise has a Custom JS Function node for arbitrary JavaScript (async functions, plus built-in and external Node modules) and a Custom Tool node for JS-based agent tools. There is no dedicated Python code-step node.',
+        shortValue: 'Yes, custom JavaScript function/tool nodes; no native Python step found',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/integrations/langchain/tools/custom-tool',
+            label: 'Flowise Docs: Custom Tool (JS function support, built-in/external modules)',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
+      apiPublishing: {
+        value:
+          'Yes: any chatflow can be called as a REST API via /api/v1/prediction/{chatflowId}, with client code generated for Python, JavaScript, and cURL, and sessionId support for maintaining conversation context.',
+        shortValue: 'Yes, REST API endpoint per flow with generated client code',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://agentsapis.com/flowise-api/',
+            label: 'Flowise API: Complete Developer Guide',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      extensibilitySdk: {
+        value:
+          'Partial: Flowise provides official embed SDKs (a flowise-embed JS package and React BubbleChat/FullPageChat components) and a documented process for building custom nodes to contribute. There is no first-party marketplace for community-built node plugins beyond the flow-template Marketplace.',
+        shortValue: 'Embed SDKs and custom-node dev docs; no plugin marketplace found',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.npmjs.com/package/flowise-embed',
+            label: 'npm: flowise-embed',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.flowiseai.com/contributing/building-node',
+            label: 'Flowise Docs: Building Node',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      mcpPublishing: {
+        value:
+          "No: Flowise's documentation covers only consuming external MCP servers as an MCP client. It has no capability for publishing a deployed Flowise flow itself as a callable MCP server for other AI tools.",
+        detail:
+          'Third-party community wrapper packages (e.g. mcp-flowise) expose Flowise chatflows via MCP externally, but this is not native.',
+        shortValue: 'No, cannot publish a flow as an MCP server',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/tutorials/tools-and-mcp',
+            label: 'Flowise Docs: Tools & MCP',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    pricing: {
+      pricingModel: {
+        value:
+          'Flowise Cloud prices by monthly prediction (execution) volume plus storage tier, with separate paid plans; self-hosting is free aside from your own infrastructure and LLM costs.',
+        shortValue: 'Prediction-volume based tiers (cloud), free self-hosting',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.lindy.ai/blog/flowise-pricing',
+            label: 'Lindy: Flowise Pricing, Features, and Alternatives for 2026',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      entryPaidPlan: {
+        value:
+          'The cheapest paid Cloud plan (Starter) is reported at $35/month, including unlimited flows, 10,000 predictions/month, and 1GB storage.',
+        detail:
+          "Sourced from third-party aggregator coverage; Flowise's own pricing page sits behind a login wall.",
+        shortValue: '$35/month Starter: unlimited flows, 10k predictions, 1GB storage',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.lindy.ai/blog/flowise-pricing',
+            label: 'Lindy: Flowise Pricing, Features, and Alternatives for 2026',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      freeTier: {
+        value:
+          'Yes: a free Cloud plan exists with 2 flows/assistants, 100 predictions per month, and 5MB storage, with community support and Flowise embed branding.',
+        shortValue: 'Yes: 2 flows, 100 predictions/month, 5MB storage',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.lindy.ai/blog/flowise-pricing',
+            label: 'Lindy: Flowise Pricing, Features, and Alternatives for 2026',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      byok: {
+        value:
+          'Yes: users configure their own LLM provider API keys as encrypted credentials within Flowise (self-hosted or cloud), so LLM usage is billed directly by the provider rather than metered by Flowise beyond its own prediction-count limits.',
+        detail: 'Flowise Cloud plans still cap by predictions/month regardless of BYOK.',
+        shortValue: 'Yes, bring your own LLM provider API keys',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/configuration/environment-variables',
+            label: 'Flowise Docs: Environment Variables',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    security: {
+      soc2: {
+        value:
+          'Unknown: a third-party security-scan aggregator (Nudge Security) lists Flowise as SOC 2 compliant among several other certifications, but Flowise has published no SOC 2 report, badge, or trust page of its own.',
+        detail:
+          'The same third-party source also claims FedRAMP and PCI compliance for a small startup, an atypical combination not corroborated on flowiseai.com.',
+        shortValue: 'No official confirmation found',
+        confidence: 'unknown',
+        sources: [],
+      },
+      dataResidency: {
+        value:
+          'Yes, indirectly: self-hosting (including on-prem/air-gapped Enterprise deployment) lets an organization fully control data location. There is no dedicated regional-cloud-hosting option for the managed Cloud product.',
+        shortValue: 'Yes via self-hosting/on-prem; no documented regional cloud option',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.lindy.ai/blog/flowise-pricing',
+            label: 'Lindy: Flowise Pricing, Features, and Alternatives for 2026',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      rbac: {
+        value:
+          'Yes: Enterprise and Cloud Workspaces support custom roles with granular per-resource permissions (full access vs. view-only). User and Workspace Management resources (Roles, Users, Workspaces, Login Activity) are restricted to Account Admins only.',
+        shortValue: 'Yes, custom roles with granular per-resource permissions (Enterprise/Cloud)',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/workspaces',
+            label: 'Flowise Docs: Workspaces',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      auditLogging: {
+        value:
+          'Yes: Workspaces (Cloud and Enterprise plans) let Account Admins see every login and logout across all users. The docs do not show a separate detailed action-by-action audit trail beyond this login activity log.',
+        shortValue: 'Yes, login activity log on Cloud and Enterprise plans',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/workspaces',
+            label: 'Flowise Docs: Workspaces',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      additionalCompliance: {
+        value:
+          'Unknown: beyond the unconfirmed third-party SOC 2 claim, Flowise has published no HIPAA, ISO 27001, PCI, or FedRAMP certification.',
+        shortValue: 'Unknown, no official certifications published',
+        confidence: 'unknown',
+        sources: [],
+      },
+      modelAndToolGovernance: {
+        value:
+          "Unknown: no documented admin controls restrict which specific LLM providers/models or which tools/integrations a given role may use. Flowise's RBAC governs resource-level (create/edit/delete) permissions, not model/tool allowlists.",
+        shortValue: 'Unknown, RBAC is resource-level not model/tool-specific',
+        confidence: 'unknown',
+        sources: [],
+      },
+      credentialGovernance: {
+        value:
+          "Partial: credentials can be shared across workspaces in Flowise's workspace model, but there is no documented way to restrict which specific stored credential a given role/permission group may use.",
+        shortValue: 'Credentials shareable across workspaces; per-role credential limits unclear',
+        confidence: 'unknown',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/workspaces',
+            label: 'Flowise Docs: Workspaces',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      whiteLabeling: {
+        value:
+          'Partial: the free plan includes Flowise\'s own embed branding, and paid plans support customizing the embedded chat widget\'s theme (colors, welcome message, tooltips). Community reports indicate fully removing the "Powered by Flowise" watermark requires workarounds, not a clean built-in option.',
+        shortValue: 'Partial: widget theming yes, full logo/brand removal unclear',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://github.com/FlowiseAI/Flowise/discussions/626',
+            label: 'GitHub Discussion #626: remove the Powered by flowise watermark',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      dataRetention: {
+        value:
+          'Unknown: no documented org-configurable retention windows for execution logs or soft-deleted resources.',
+        shortValue: 'Unknown, not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      piiRedaction: {
+        value:
+          'Unknown: no documented PII detection/redaction feature for workflow content or logs.',
+        shortValue: 'Unknown, not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      sso: {
+        value:
+          'Yes, with a caveat: Enterprise-plan SSO supports OIDC via Microsoft Azure/Entra ID, Google, and Auth0, but has no automatic org auto-provisioning. Invited users must be added first before SSO login works.',
+        detail: 'No SAML support documented.',
+        shortValue: 'Yes (OIDC, Enterprise plan), but no auto-provisioning',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/configuration/sso',
+            label: 'Flowise Docs: SSO',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      thirdPartyVetting: {
+        value:
+          "Yes: Flowise's nodes (LLMs, tools, vector stores, document loaders) live in the packages/components/nodes folder of the core FlowiseAI/Flowise monorepo. New nodes are contributed via GitHub pull request and reviewed/merged by the Flowise team before shipping in an official release, rather than published independently by third parties into an open, unreviewed marketplace. The separate Marketplace feature distributes JSON chatflow/agentflow templates, not installable executable code.",
+        detail:
+          "That PR-review process has not stopped a critical incident in vetted, first-party code: CVE-2025-59528 (CVSS 10.0) was an unauthenticated remote code execution flaw in the official CustomMCP node, where user-supplied mcpServerConfig input was passed into a JavaScript Function() constructor. Patched in 3.0.6, but VulnCheck observed in-the-wild exploitation starting April 2026 against thousands of still-exposed instances. By contrast, Sim documents its own thirdPartyVetting fact as every one of its 302 blocks being first-party authored and code-reviewed with no public marketplace for third-party executable code either, so the two products share the same no-open-marketplace posture; the difference is that Flowise's own review pipeline has already shipped one CVSS-10 RCE into a first-party node, which is the concrete cost of that model rather than of an unreviewed community ecosystem.",
+        shortValue:
+          'Yes, PR-reviewed into the core repo, but that pipeline already shipped a CVSS-10 RCE',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/contributing/building-node',
+            label: 'Flowise Docs: Building Node',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://github.com/FlowiseAI/Flowise/security/advisories/GHSA-3gcm-f6qx-ff7p',
+            label: 'GitHub Security Advisory GHSA-3gcm-f6qx-ff7p (CVE-2025-59528)',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.csoonline.com/article/4155680/hackers-exploit-a-critical-flowise-flaw-affecting-thousands-of-ai-workflows.html',
+            label:
+              'CSO Online: Hackers exploit a critical Flowise flaw affecting thousands of AI workflows',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    observability: {
+      tracingDepth: {
+        value:
+          'Yes: Flowise provides built-in analytics/observability and integrates with third-party tracing tools (Langfuse, Opik) for per-execution, block-level trace views including duration, cost, and token usage, beyond simple aggregate stats.',
+        shortValue:
+          'Yes, per-block trace views via built-in analytics and Langfuse/Opik integration',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://langfuse.com/integrations/no-code/flowise',
+            label: 'Langfuse: Observability and Tracing for Flowise',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      durabilityModel: {
+        value:
+          'Unknown: no documentation describes automatic retries, checkpointing, or replay of a past execution with its original inputs.',
+        shortValue: 'Unknown, not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      failureAlerting: {
+        value:
+          'Unknown: no documented proactive notification (email/Slack/webhook) when a run fails or crosses a cost/latency threshold, beyond viewing failures in logs/observability tools.',
+        shortValue: 'Unknown, not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      dataDrains: {
+        value:
+          'Partial: Flowise supports exporting execution traces to external observability platforms (Langfuse, Opik) on an ongoing basis, but has no documented way to export raw execution/audit/usage data to generic destinations like S3, BigQuery, or Datadog.',
+        shortValue: 'Partial: trace export to Langfuse/Opik only, no generic data-drain found',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://langfuse.com/integrations/no-code/flowise',
+            label: 'Langfuse: Observability and Tracing for Flowise',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      asyncExecution: {
+        value:
+          'Partial: Flowise supports a queue-based execution mode ("Running Flowise using Queue") for scaling background job processing, but the standard /api/v1/prediction endpoint is documented as a synchronous call, with no clear poll-for-result async API pattern.',
+        shortValue: 'Partial: queue mode exists, prediction API is documented as synchronous',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/configuration/running-flowise-using-queue',
+            label: 'Flowise Docs: Running Flowise using Queue',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      executionLimits: {
+        value:
+          'Unknown: Flowise publishes no numbers for maximum single-execution duration or concurrency limits, beyond monthly prediction-count caps tied to Cloud pricing tiers.',
+        shortValue: 'Unknown, only monthly prediction caps are published',
+        confidence: 'unknown',
+        sources: [],
+      },
+      partialFailureHandling: {
+        value:
+          'Yes: Agentflow V2\'s conditional branching and Human Input reject-path let a workflow route around a problematic step (e.g. loop back for refinement) rather than only halting entirely, though there is no dedicated "catch/error-handler" node distinct from conditional routing.',
+        shortValue: 'Yes, via conditional branching / reject-loop paths in Agentflow V2',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/using-flowise/agentflowv2',
+            label: 'Flowise Docs: Agentflow V2',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      unattendedExecution: {
+        value:
+          'Yes, for the triggers Flowise has: a chat message, a REST API prediction call, or an MCP tool invocation all execute entirely on the Flowise server (self-hosted or Flowise Cloud), with no dependency on a client device staying open, awake, or connected. Flowise has no dedicated cron/schedule trigger of its own, so a genuinely unattended, time-based run has to come from an external scheduler (e.g. a cron job or another system calling the prediction API) rather than a built-in scheduling engine.',
+        detail:
+          'Once a run is invoked by any supported means, closing the browser tab or disconnecting the calling client has no effect on that run completing server-side; the caveat is only that Flowise itself cannot originate a scheduled run without an outside trigger.',
+        shortValue: 'Yes for triggered runs; no built-in scheduler to originate one unattended',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://agentsapis.com/flowise-api/',
+            label: 'Flowise API: Complete Developer Guide',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.flowiseai.com/configuration/running-flowise-using-queue',
+            label: 'Flowise Docs: Running Flowise using Queue',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    support: {
+      supportChannels: {
+        value:
+          'Flowise offers community support (GitHub, Discord) on free/self-hosted tiers, priority support on the Pro Cloud plan, and personalized/dedicated support on Enterprise.',
+        shortValue: 'Community (free), priority (Pro), dedicated (Enterprise)',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.lindy.ai/blog/flowise-pricing',
+            label: 'Lindy: Flowise Pricing, Features, and Alternatives for 2026',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      sla: {
+        value:
+          'A formal SLA (99.99% uptime) is offered on the Enterprise plan per third-party coverage; no SLA is documented for lower tiers.',
+        detail: 'No official Flowise SLA page confirms this figure.',
+        shortValue: 'Yes, ~99.99% SLA claimed on Enterprise plan',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.lindy.ai/blog/flowise-pricing',
+            label: 'Lindy: Flowise Pricing, Features, and Alternatives for 2026',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
+      community: {
+        value:
+          "Flowise's GitHub repository has approximately 54,000 stars (Apache 2.0 licensed core), with an active Discord community whose exact member count is not published.",
+        shortValue: '~54,000 GitHub stars, active Discord community',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://github.com/FlowiseAI/Flowise',
+            label: 'GitHub: FlowiseAI/Flowise',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      companyMaturity: {
+        value:
+          'Flowise was founded in April 2023 (Y Combinator-backed), raised approximately $500K in early funding, and was acquired by Workday in August 2025, bringing enterprise backing while keeping the open-source Community Edition intact.',
+        shortValue: 'Founded 2023 (YC), acquired by Workday Aug 2025',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://www.prnewswire.com/news-releases/workday-acquires-flowise-bringing-powerful-ai-agent-builder-capabilities-to-the-workday-platform-302530557.html',
+            label: 'PR Newswire: Workday Acquires Flowise',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      academy: {
+        value:
+          'Flowise runs no official academy or certification program. Third-party platforms (Coursera, Codecademy, Udemy) offer independent Flowise courses and certificates of completion, and Flowise maintains standard docs and YouTube tutorials.',
+        shortValue: 'No official academy; only third-party courses exist',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://www.coursera.org/learn/designing-a-customer-support-chatbot-using-flowise',
+            label: 'Coursera: Designing a Customer Support Chatbot Using Flowise',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+  },
+}

apps/sim/lib/compare/data/competitors/langflow.ts

@@ -0,0 +1,992 @@
+import { LangflowIcon } from '@/components/icons'
+import type { CompetitorProfile } from '@/lib/compare/data/types'
+
+/** Researched and cross-verified against live vendor sources on 2026-07-02. */
+export const langflowProfile: CompetitorProfile = {
+  id: 'langflow',
+  name: 'Langflow',
+  website: 'https://www.langflow.org',
+  brand: {
+    icon: LangflowIcon,
+    selfFramed: true,
+    colors: ['#D31E47', '#7A7272'],
+    source: 'GitHub organization avatar',
+    asOf: '2026-07-02',
+  },
+  oneLiner:
+    'Langflow is an open-source, Python-based visual builder for creating and deploying AI agents and RAG (retrieval-augmented generation) applications, owned by DataStax (an IBM company).',
+  standoutFeatures: [
+    {
+      title: 'Deep LangChain/Python component ecosystem',
+      description:
+        "Langflow ships hundreds of drag-and-drop components organized into core groups and provider bundles (Google, OpenAI, LangChain, Elastic, Composio, and more). Any component's underlying Python code can also be edited directly for full customization.",
+      shortDescription:
+        'Hundreds of customizable Python/LangChain components and provider bundles.',
+      source: {
+        url: 'https://docs.langflow.org/concepts-components',
+        label: 'Langflow Docs: Components overview',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'Zero-step MCP server exposure',
+      description:
+        'Every Langflow project is automatically registered as an MCP server the moment it is created, exposing any flow with a Chat Output as a callable MCP tool with no separate publish or deploy step. Sim also supports both MCP client and server roles, but publishing a workflow as an MCP tool requires an explicit deploy step.',
+      shortDescription:
+        'Every project auto-registers as an MCP server on creation, no deploy step.',
+      source: {
+        url: 'https://docs.langflow.org/mcp-server',
+        label: 'Langflow Docs: Use Langflow as an MCP server',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'Explicit flow version history with restore',
+      description:
+        'The flow editor has a Version History panel where users manually save named snapshots, preview a prior version in read-only mode, and restore it. It can optionally auto-back up the current draft first, and this is separate from the continuous auto-save of the working draft.',
+      shortDescription: 'Manual flow snapshots with preview and one-click restore.',
+      source: {
+        url: 'https://docs.langflow.org/concepts-flows',
+        label: 'Langflow Docs: Build flows',
+        asOf: '2026-07-02',
+      },
+    },
+  ],
+  limitations: [
+    {
+      title: 'No real-time multiplayer editing',
+      description:
+        "Multiple users cannot co-edit the same flow with live cursors or synced operations. There's an open community feature request for real-time collaboration like Figma or n8n's. Current practice is exporting flows as JSON and merging changes like code, or sharing an account.",
+      shortDescription:
+        'No live multi-user co-editing; only JSON export/import or shared accounts.',
+      source: {
+        url: 'https://github.com/langflow-ai/langflow/issues/1864',
+        label: 'GitHub Issue 1864: Collaborative/Access Control enhancement',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'Lowest enterprise-readiness scores in third-party benchmark',
+      description:
+        "n8n's 2026 AI Agent Development Tools report scored Langflow 35 percent on Codability and 30 percent on Enterprisiness, the lowest of the vendors evaluated, citing gaps in agent sandboxing, security guardrail maturity, and evaluation frameworks.",
+      shortDescription:
+        "Scored lowest on codability (35%) and enterprisiness (30%) in n8n's 2026 report.",
+      source: {
+        url: 'https://n8n.io/reports/2026-ai-agent-development-tools/#vendors',
+        label: 'n8n: 2026 AI Agent Development Tools report',
+        asOf: '2026-07-02',
+      },
+    },
+  ],
+  facts: {
+    platform: {
+      builderType: {
+        value:
+          "Langflow is primarily a visual drag-and-drop canvas builder for connecting components into a flow. Every component's Python source is directly editable for code-level customization, and a Langflow Assistant can help build or edit flows conversationally.",
+        detail: 'Core paradigm is visual; code editing and an AI assistant are supplementary.',
+        shortValue: 'Visual canvas plus editable Python code, some NL assist',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/concepts-components',
+            label: 'Langflow Docs: Components overview',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.langflow.org/langflow-assistant',
+            label: 'Langflow Docs: Langflow Assistant',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      learningCurve: {
+        value:
+          'Langflow targets developers comfortable with Python and LangChain concepts such as embeddings, vector stores, chunking, and prompt chains. Non-technical users can use starter templates, but customizing components or debugging chains requires a technical background.',
+        shortValue: 'Moderate to steep, aimed at developers',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/starter-projects-vector-store-rag',
+            label: 'Langflow Docs: Vector store RAG starter project',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      selfHostOption: {
+        value:
+          'Yes: Langflow is fully open source (MIT licensed) and can be self-hosted via pip/uv local install, Docker, or Kubernetes, in addition to a desktop app and Langflow Cloud.',
+        shortValue: 'Yes, self-hostable (pip, Docker, K8s)',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/get-started-installation',
+            label: 'Langflow Docs: Install Langflow',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://github.com/langflow-ai/langflow',
+            label: 'GitHub: langflow-ai/langflow',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      deploymentOptions: {
+        value:
+          'Langflow can run as a desktop app on Windows/macOS, a local pip/uv install, a Docker container, or a Kubernetes deployment, plus a hosted Langflow Cloud option with a free account tier. Multi-worker setups are documented for scaling self-hosted instances.',
+        shortValue: 'Desktop, local, Docker/K8s, cloud, self-hosted',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/get-started-installation',
+            label: 'Langflow Docs: Install Langflow',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.langflow.org/deployment-kubernetes-dev',
+            label: 'Langflow Docs: Kubernetes deployment',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.langflow.org/deployment-multi-worker',
+            label: 'Langflow Docs: Deploy Langflow with multiple workers',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      templates: {
+        value:
+          'Yes: Langflow ships starter projects and templates, including Basic Prompting, Vector Store RAG, Document Q&A, Memory Chatbot, Blog Writer, and Simple Agent. These are accessible from a Templates modal when creating a new flow, plus a public templates gallery on langflow.org.',
+        shortValue: 'Yes, built-in starter project templates',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/starter-projects-basic-prompting',
+            label: 'Langflow Docs: Basic prompting starter project',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.langflow.org/templates/use-langflow-to-build-local-rag-pipeline-with-ollama-and-chromadb',
+            label: 'Langflow templates gallery example',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      license: {
+        value:
+          "Langflow's core is MIT licensed, a permissive open-source license, per its public GitHub repository.",
+        shortValue: 'MIT license',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://github.com/langflow-ai/langflow',
+            label: 'GitHub: langflow-ai/langflow (License: MIT)',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      environmentPromotion: {
+        value:
+          "Unknown: no public documentation describes forking or cloning a full project or workspace and promoting changes between separate dev/qa/prod environments. Langflow's version history operates at the single-flow level, not the project or environment level.",
+        detail: 'Version history is per-flow snapshotting, not multi-environment promotion.',
+        shortValue: 'Unknown, no project-level env promotion documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      versionControlDepth: {
+        value:
+          'Yes: Langflow has a Version History menu for saving named snapshots of a flow, previewing a saved version in read-only mode, and restoring it, with an optional auto-backup of the current draft first. Auto-save of the working draft runs separately from these explicit versions.',
+        detail: 'No diff/compare view or branching documented.',
+        shortValue: 'Manual snapshots, preview, and restore',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/concepts-flows',
+            label: 'Langflow Docs: Build flows',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      realtimeCollaboration: {
+        value:
+          "No: real-time multi-user editing of the same flow isn't available. It's an open community feature request; current practice is JSON export/import or Git-based merging of flows between teammates.",
+        shortValue: 'No live multi-user co-editing',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://github.com/langflow-ai/langflow/issues/1864',
+            label: 'GitHub Issue 1864: Collaborative/Access Control enhancement',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      nativeFileStorage: {
+        value:
+          'Partial: Langflow has a per-server File Management system with a local or S3 storage backend, letting files be uploaded once and reused across flows. There is no documented folder hierarchy, link-based sharing with auth options, or deleted-item recovery.',
+        shortValue: 'Basic shared file store, no folders/sharing/trash',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/concepts-file-management',
+            label: 'Langflow Docs: Manage files',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      dataTables: {
+        value:
+          "No: Langflow's documentation does not describe a native spreadsheet-like data table feature. It exposes Data and DataFrame object types used to pass structured data between components, not a persistent spreadsheet UI.",
+        shortValue: 'No native spreadsheet-style data table',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/components-data',
+            label: 'Langflow Docs: Data components',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      richTextEditor: {
+        value:
+          'Unknown: no public documentation describes an inline rich-text or WYSIWYG markdown editor for documents stored in Langflow; file handling documentation covers upload and parsing, not in-app document editing.',
+        shortValue: 'Unknown, no WYSIWYG editor documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      subWorkflows: {
+        value:
+          "Yes: Langflow's Run Flow component runs another saved flow as a subprocess of the current flow, dynamically generating input and output fields from the target flow's graph so the parent flow passes data in and receives the child flow's outputs back. It can also be attached to an Agent component as a callable tool.",
+        shortValue: 'Yes, via the Run Flow component',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/run-flow',
+            label: 'Langflow Docs: Run Flow component',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      customBlocks: {
+        value:
+          "No: Langflow has no documented mechanism to publish a deployed flow as an encapsulated, named block that appears org-wide in the component sidebar for other users to drop into their own separate flows. The closest features are narrower: grouping components and saving them creates a static snapshot copy in the creating user's own Core components menu, with no documented auto-sync back to a source flow's latest version; and the legacy Langflow Store lets a user publish a component or flow to a public, account-based marketplace rather than a governed, org-scoped, live-linked block. Its Run Flow component (see subWorkflows) is same-project subflow composition, not org-wide reuse by other users.",
+        detail:
+          "Neither mechanism matches Sim's model of a workspace admin publishing a deployed workflow as a block that all consumers see in the shared toolbar, auto-tracks the source's latest deployed version, and hides the source's internal steps and credentials.",
+        shortValue: 'No, only static component snapshots or a public component store',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/concepts-components',
+            label: 'Langflow Docs: Components overview (grouping and saving components)',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://github.com/langflow-ai/langflow/discussions/4406',
+            label: 'GitHub Discussion 4406: How to save a custom component to the sidebar?',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
+    },
+    aiCapabilities: {
+      multiLlmSupport: {
+        value:
+          "Langflow supports configuring multiple LLM providers globally via Settings > Model Providers, each with its own API key, including OpenAI and Ollama for local or self-hosted models. The full list of supported providers is only shown in the running app's UI, not enumerated in the docs.",
+        detail: 'Exact provider count not fully published in docs.',
+        shortValue: 'Multiple providers via global Model Providers settings',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/components-models',
+            label: 'Langflow Docs: Language Model component',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.langflow.org/blog/local-ai-using-ollama-with-agents',
+            label: 'Langflow blog: Using Ollama with agents',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      agentReasoningBlocks: {
+        value:
+          'Yes: Langflow has a dedicated Agent and Tool Calling Agent component that uses a connected LLM to reason over input and select among connected tools to complete a task, distinct from plain data-routing components.',
+        shortValue: 'Yes, dedicated Agent and Tool Calling Agent components',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/agents',
+            label: 'Langflow Docs: Use Langflow agents',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.langflow.org/components-agents',
+            label: 'Langflow Docs: Agents component',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      naturalLanguageBuilding: {
+        value:
+          'Yes: Langflow Assistant lets users build and edit flows and components using natural language prompts inside the editor.',
+        shortValue: 'Yes, via Langflow Assistant',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/langflow-assistant',
+            label: 'Langflow Docs: Langflow Assistant',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      knowledgeBaseRag: {
+        value:
+          'Yes: Langflow has a documented Vector Store RAG (retrieval-augmented generation) pattern with a two-flow setup for ingestion and query, a Split Text component for chunking, embedding-model components, and connectors to vector stores such as Astra DB and Milvus.',
+        shortValue: 'Yes, built-in RAG pipeline components and vector store connectors',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/starter-projects-vector-store-rag',
+            label: 'Langflow Docs: Vector store RAG starter project',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      mcpSupport: {
+        value:
+          'Yes: Langflow can act as an MCP client via the MCP Tools component, connecting to external MCP servers (using JSON config, STDIO, or HTTP/SSE) and exposing their functions as tools for agents.',
+        shortValue: 'Yes, consumes external MCP servers as tools',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/mcp-client',
+            label: 'Langflow Docs: Use Langflow as an MCP client',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.langflow.org/mcp-tools',
+            label: 'Langflow Docs: MCP Tools component',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      evaluationGuardrails: {
+        value:
+          'Yes: Langflow has a Guardrails component that uses an LLM to check input against built-in categories such as PII, tokens and passwords, jailbreak attempts, offensive content, malicious code, and prompt injection. It also has evaluation components and integrations like Cleanlab Evaluator and LangWatch Evaluator for scoring responses.',
+        shortValue: 'Yes, Guardrails component plus Cleanlab/LangWatch evaluators',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/guardrails',
+            label: 'Langflow Docs: Guardrails',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.langflow.org/bundles-cleanlab',
+            label: 'Langflow Docs: Cleanlab bundle',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      humanInTheLoop: {
+        value:
+          'Unknown: no official Langflow documentation describes a dedicated pause-and-wait-for-human-approval mechanism mid-run. A community GitHub discussion asking how to implement human-in-the-loop suggests it is not a standard built-in feature, unlike LangGraph or FlowiseAI, which do document this.',
+        detail:
+          'A user discussion asked how to build this, implying no first-class component exists.',
+        shortValue: 'Unknown, not documented as a built-in feature',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://github.com/langflow-ai/langflow/discussions/4399',
+            label: 'GitHub Discussion 4399: How to implement human in the loop?',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      generativeMedia: {
+        value:
+          'Unknown: no official Langflow documentation describes built-in image, video, or audio generation components. Community discussions show users integrating image generation via custom components or external APIs, not a native block.',
+        shortValue: 'Unknown, no native generative media blocks documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      dynamicToolUse: {
+        value:
+          "No: tools are connected to the Agent component's Tools input at build time in the flow editor, and the connected LLM only chooses among that pre-wired set at run time based on each tool's description. It does not browse or select from a broader catalog, such as an entire MCP server's tool list, at inference time.",
+        detail:
+          "Same closed-list function-calling mechanism as Sim's Agent block: the pool is whatever is wired into the flow, not the entire platform or an MCP catalog.",
+        shortValue: 'No, agent picks only among tools wired in at build time',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/agents-tools',
+            label: 'Langflow Docs: Configure tools for agents',
+            asOf: '2026-07-04',
+          },
+        ],
+      },
+      modelFallback: {
+        value:
+          'Unknown: no public Langflow documentation describes automatic fallback or retry to a different model or provider on a failed or rate-limited LLM call. A blog post shows manually building smart model routing as a custom flow rather than a built-in fallback feature.',
+        detail: 'Users can hand-build routing flows, but it is not an automatic platform feature.',
+        shortValue: 'Unknown, no built-in automatic model fallback documented',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.langflow.org/blog/how-to-build-your-own-gpt-5',
+            label: 'Langflow blog: Build Your Own GPT-5 with Smart Model Routing',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      agentSkills: {
+        value:
+          'Unknown: no public documentation describes a reusable, named prompt or knowledge-snippet library invokable by reference across agents, distinct from a one-off system prompt field on each agent component.',
+        shortValue: 'Unknown, no named reusable skill library documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      nativeChatDeployment: {
+        value:
+          'Yes: Langflow provides a Shareable Playground at a public flow link and an official Embedded Chat widget that can be added to any website to expose a flow as a conversational chat surface.',
+        shortValue: 'Yes, shareable playground and embeddable chat widget',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/embedded-chat-widget',
+            label: 'Langflow Docs: Embedded chat widget',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.langflow.org/concepts-playground',
+            label: 'Langflow Docs: Test flows in the Playground',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      kbChunkVisibility: {
+        value:
+          'Unknown: no public documentation was found showing a dedicated chunk-level debugging or search-result view that surfaces individual chunk index or content for a knowledge-base query, beyond the general chunking configuration in the Split Text component.',
+        shortValue: 'Unknown, no dedicated chunk-level results view documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      parallelExecution: {
+        value:
+          'No: no dedicated fan-out/fan-in feature is documented. Langflow builds a flow into a Directed Acyclic Graph and executes nodes in dependency order, each node run using the results of the nodes it depends on: sequential DAG traversal, not a native concurrent-branch-then-join primitive.',
+        shortValue: 'Not documented, execution model is sequential DAG traversal',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/concepts-flows',
+            label: 'Langflow Docs: Build flows (DAG execution order)',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      a2aProtocol: {
+        value:
+          'No: native A2A protocol support is not shipped in Langflow core. A community member submitted a working implementation and feature request in November 2025, but it remains an open enhancement request (closed as a duplicate of an earlier tracking issue), not a merged feature. The only path to A2A interoperability is third-party custom components.',
+        shortValue: 'No, open feature request only, not shipped in core',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://github.com/langflow-ai/langflow/issues/10658',
+            label: 'GitHub langflow-ai/langflow Issue #10658: Add A2A Protocol Support',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://github.com/langflow-ai/langflow/issues/10241',
+            label: 'GitHub langflow-ai/langflow Issue #10241: A2A (tracking issue)',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      loopIteration: {
+        value:
+          'Yes: Langflow ships a dedicated Loop component that takes a list of JSON or Table items (for example CSV rows), passes items one at a time through its Item output port to a chain of connected components, and loops back until every item is processed sequentially, before emitting the aggregated result from its Done port.',
+        shortValue: 'Yes, via the Loop component (sequential, Item/Done ports)',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/loop',
+            label: 'Langflow Docs: Loop component',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    integrations: {
+      integrationCount: {
+        value:
+          "Langflow organizes third-party integrations as component bundles grouped by provider, such as Google, OpenAI, LangChain, Elastic, and Composio. The full current list of bundles and components is only visible in the app's Bundles panel, not enumerated on the docs site.",
+        shortValue: 'Dozens of provider bundles; full count only in-app',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/components-bundle-components',
+            label: 'Langflow Docs: About bundles',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      triggerTypes: {
+        value:
+          'Yes: Langflow flows can be triggered via the REST API run and advanced run endpoints, a dedicated Webhook component for event-driven HTTP POST triggers, the Playground or chat interface, or external schedulers like cron or Airflow calling the API.',
+        detail: 'Scheduling itself is via external tools, not a native in-app scheduler.',
+        shortValue: 'API run, webhook, chat, and external cron/scheduler calls',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/webhook',
+            label: 'Langflow Docs: Trigger flows with webhooks',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.langflow.org/api-flows-run',
+            label: 'Langflow Docs: Flow trigger endpoints',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      customCodeSteps: {
+        value:
+          "Yes: Langflow supports custom Python components with full source-code editing, including lifecycle hooks like pre-run setup and typed inputs/outputs from Langflow's own component library (the `lfx.io` module), for arbitrary custom logic inside a flow.",
+        shortValue: 'Yes, custom Python components with full code access',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/components-custom-components',
+            label: 'Langflow Docs: Create custom Python components',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      apiPublishing: {
+        value:
+          "Yes: any flow can be called as a REST API via documented run endpoints, with an auto-generated API reference (OpenAPI spec) available at the deployment's docs endpoint.",
+        shortValue: 'Yes, flows callable via REST API with OpenAPI spec',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/api-reference-api-examples',
+            label: 'Langflow Docs: Get started with the Langflow API',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      extensibilitySdk: {
+        value:
+          'Yes: Langflow supports custom Python component development with documented input and output classes, plus a separate open-source Embedded Chat widget package for embedding. Community members can also contribute components, bundles, and templates back via GitHub, but there is no formal third-party marketplace documented.',
+        detail: 'No formal marketplace documented.',
+        shortValue: 'Custom component SDK, embed widget, community contributions',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/components-custom-components',
+            label: 'Langflow Docs: Create custom Python components',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://github.com/langflow-ai/langflow-embedded-chat',
+            label: 'GitHub: langflow-ai/langflow-embedded-chat',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      mcpPublishing: {
+        value:
+          'Yes: Langflow automatically registers each project as an MCP server when created, exposing every flow that has a Chat Output component as a callable MCP tool for any external MCP client.',
+        shortValue: 'Yes, every project auto-exposed as an MCP server',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/mcp-server',
+            label: 'Langflow Docs: Use Langflow as an MCP server',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    pricing: {
+      pricingModel: {
+        value:
+          "Langflow's core software is free and open source, with no license fee for self-hosting. Third-party sources describe Langflow Cloud as offering a free account tier plus a paid tier around $25 per month for higher usage limits, and separate enterprise pricing; Langflow's official pricing page does not confirm these figures directly.",
+        detail:
+          "Based on third-party summaries; the official pricing page doesn't confirm these figures.",
+        shortValue: 'Free open-source core; cloud free tier plus paid/enterprise tiers',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.lindy.ai/blog/langflow-pricing',
+            label: 'Lindy: Langflow Pricing',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://automationatlas.io/tools/langflow/',
+            label: 'Automation Atlas: Langflow pricing summary',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      entryPaidPlan: {
+        value:
+          "Unknown: the exact entry paid-plan price and inclusions aren't confirmed on Langflow's own official pricing page. Third-party summaries cite a cloud paid tier starting around $25 per month.",
+        detail: 'Not confirmed against an official Langflow source.',
+        shortValue: 'Unverified; third parties cite roughly $25/month',
+        confidence: 'unknown',
+        sources: [],
+      },
+      freeTier: {
+        value:
+          'Yes: the open-source core is free to self-host, with no usage caps beyond your own infrastructure. Langflow Cloud reportedly offers a free account tier before infrastructure and API costs apply.',
+        detail: 'Exact cloud free-tier limits not officially confirmed.',
+        shortValue: 'Yes, free self-hosted core plus a free cloud tier',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.lindy.ai/blog/langflow-pricing',
+            label: 'Lindy: Langflow Pricing',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      byok: {
+        value:
+          'Yes: Langflow requires users to configure their own LLM provider API keys per provider in Settings > Model Providers, meaning usage is billed directly by the LLM provider, not marked up by Langflow.',
+        shortValue: 'Yes, users supply their own provider API keys',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/agents',
+            label: 'Langflow Docs: Use Langflow agents',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    security: {
+      soc2: {
+        value:
+          "Unknown: no public documentation or official page states a SOC 2 certification for Langflow. The docs' Security page discusses infrastructure-level responsibility for operators, not a compliance certification.",
+        detail:
+          'Security docs place isolation and compliance burden on the deploying organization.',
+        shortValue: 'Unknown, no SOC2 certification documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      dataResidency: {
+        value:
+          'Yes via self-hosting: Langflow can be fully self-hosted on Docker, Kubernetes, on-prem, or any cloud region, giving organizations full control over data residency. No dedicated managed regional-hosting product is documented for Langflow Cloud.',
+        shortValue: 'Yes via self-hosting; no documented managed regional cloud',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/get-started-installation',
+            label: 'Langflow Docs: Install Langflow',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      rbac: {
+        value:
+          "Unknown: Langflow's own Security documentation states it neither enforces isolation between users within a single Langflow process nor restricts access to local disk or network resources, relying on infrastructure-level security for multi-tenant deployments. No native role-based access control system with distinct roles or scopes is documented.",
+        shortValue: 'Unknown/limited, docs say isolation is infra-level not built-in',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/security',
+            label: 'Langflow Docs: Security',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      auditLogging: {
+        value:
+          'Unknown: no official documentation describes a queryable or exportable audit log of user actions gated by plan. Langflow does document general execution and system logging for debugging, which is distinct from a security audit trail.',
+        shortValue: 'Unknown, only general execution logs documented',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/concepts-flows',
+            label: 'Langflow Docs: Build flows',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      additionalCompliance: {
+        value:
+          'Unknown: no public documentation or official page confirms HIPAA, ISO 27001, GDPR-specific attestation, PCI, or FedRAMP certification for Langflow.',
+        shortValue: 'Unknown, no compliance certifications documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      modelAndToolGovernance: {
+        value:
+          'Unknown: no public documentation describes an admin-configurable restriction on which LLM providers, models, or tools a given role or user may use. Model Providers configuration in Settings appears to be workspace-wide rather than per-role gated.',
+        shortValue: 'Unknown, no per-role model/tool restriction documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      credentialGovernance: {
+        value:
+          'Unknown: no public documentation describes restricting which specific stored credentials a role or permission group may use, beyond standard per-user API key configuration.',
+        shortValue: 'Unknown, no per-role credential restriction documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      whiteLabeling: {
+        value:
+          "Unknown: no public documentation describes replacing Langflow's branding, such as logo, product name, or theme, in the self-hosted UI or embedded chat widget, beyond basic widget style customization exposed as embed props.",
+        detail:
+          'The embed widget supports styling props but full logo and name replacement across the whole app was not confirmed.',
+        shortValue: 'Unknown; only chat-widget style props documented, not full rebrand',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://github.com/langflow-ai/langflow-embedded-chat',
+            label: 'GitHub: langflow-ai/langflow-embedded-chat',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      dataRetention: {
+        value:
+          'Unknown: no public documentation describes an org-configurable retention window for execution logs or soft-deleted resources. Self-hosters control their own database and log retention at the infrastructure level, since Langflow stores data in a configured database plus local or S3 file storage.',
+        shortValue: 'Unknown, retention managed at self-hosted infra level',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/concepts-file-management',
+            label: 'Langflow Docs: Manage files',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      piiRedaction: {
+        value:
+          'Yes: the built-in Guardrails component includes a documented PII category that uses an LLM check to detect names, addresses, phone numbers, emails, social security numbers, and credit card numbers in workflow content. This is detection and validation, not confirmed automatic redaction of retained logs.',
+        detail:
+          'Documented as detection and validation; automatic redaction of stored logs specifically was not confirmed.',
+        shortValue: 'Yes, Guardrails component detects PII in content',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/guardrails',
+            label: 'Langflow Docs: Guardrails',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      sso: {
+        value:
+          'Unknown: no official Langflow documentation confirms SAML or OIDC single sign-on with organization auto-provisioning. Authentication docs cover API-key-based authentication, and third-party summaries mention SSO as a roadmap item, not a shipped, documented feature.',
+        detail: 'Some community sources describe SSO as planned rather than confirmed shipped.',
+        shortValue: 'Unknown, not confirmed as a documented shipped feature',
+        confidence: 'unknown',
+        sources: [],
+      },
+      thirdPartyVetting: {
+        value:
+          'Partial: Langflow disclosed CVE-2025-3248, an unauthenticated remote code execution flaw in the custom-component code-validation endpoint, fixed in version 1.3.0; security researchers confirmed it was actively exploited in the wild to deploy the Flodrix botnet on unpatched instances before the fix shipped. That incident reflects the underlying trust model: built-in integration bundles are contributed by third-party contributors as pull requests to the official langflow-ai/langflow codebase and reviewed and merged by core maintainers, but Langflow also ships a custom-component system that lets any user author and run their own Python code with full server access, the same trust level as the core server itself.',
+        detail:
+          "Langflow documents that it does not enforce isolation between users or restrict local disk/network access, so custom-component code runs with the same trust level as the core server. By contrast, every one of Sim's blocks is first-party authored and code-reviewed through Sim's own pull-request process, and Sim has no public marketplace where a third party can publish installable executable tool code.",
+        shortValue:
+          'Partial: disclosed CVE-2025-3248 RCE exploited via Flodrix botnet; custom code runs at full server trust',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/components-bundle-components',
+            label: 'Langflow Docs - About bundles',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://docs.langflow.org/contributing-components',
+            label: 'Langflow Docs - Contribute components',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://docs.langflow.org/components-custom-components',
+            label: 'Langflow Docs - Create custom Python components',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://docs.langflow.org/security',
+            label: 'Langflow Docs - Security',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://github.com/langflow-ai/langflow/security/advisories/GHSA-rvqx-wpfh-mfx7',
+            label: 'GitHub Security Advisory GHSA-rvqx-wpfh-mfx7 (CVE-2025-3248)',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://www.securityweek.com/recent-langflow-vulnerability-exploited-by-flodrix-botnet/',
+            label: 'SecurityWeek - Langflow Vulnerability Exploited by Flodrix Botnet',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
+    },
+    observability: {
+      tracingDepth: {
+        value:
+          'Yes: Langflow automatically captures step-by-step execution traces within a flow run. It can forward detailed traces, including prompts, responses, token usage, latency, and intermediate steps, to external observability platforms such as LangSmith, Langfuse, and LangWatch via environment-variable configuration.',
+        detail:
+          'Deep trace visualization relies on integrating an external observability platform.',
+        shortValue: 'Per-step traces, exportable to LangSmith/Langfuse/LangWatch',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/integrations-langfuse',
+            label: 'Langflow Docs: Langfuse integration',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.langflow.org/integrations-langsmith',
+            label: 'Langflow Docs: LangSmith integration',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      durabilityModel: {
+        value:
+          'Unknown: no public documentation describes automatic retries, checkpointing, or replaying a past execution with its original inputs at the platform level. This is a documented LangGraph capability, not confirmed for Langflow flows specifically.',
+        shortValue: 'Unknown, no documented replay/checkpoint model for flows',
+        confidence: 'unknown',
+        sources: [],
+      },
+      failureAlerting: {
+        value:
+          'Unknown: no public documentation describes proactive notification, such as email, Slack, or webhook alerts, when a flow run fails or crosses a cost or latency threshold. Available integrations focus on logging and tracing rather than alerting.',
+        shortValue: 'Unknown, no proactive failure alerting documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      dataDrains: {
+        value:
+          'Partial: Langflow supports continuously forwarding execution trace data to external observability platforms such as LangSmith, Langfuse, and LangWatch via configuration. No general-purpose data drain to arbitrary destinations like S3, BigQuery, or a generic webhook for audit or usage data was found documented.',
+        shortValue: 'Trace export to LangSmith/Langfuse/LangWatch only',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/integrations-langfuse',
+            label: 'Langflow Docs: Langfuse integration',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      asyncExecution: {
+        value:
+          "Partial: Langflow documents a webhook-triggered flow execution pattern and a Monitor endpoints page for checking flow build and run status, giving some support for background triggering and later status checks. A dedicated async job-polling API pattern isn't fully documented.",
+        shortValue: 'Some support via webhook trigger plus monitor endpoints',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/api-monitor',
+            label: 'Langflow Docs: Monitor endpoints',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      executionLimits: {
+        value:
+          "Unknown: Langflow's official documentation publishes no concrete numbers for maximum single-execution duration or concurrent run limits. Self-hosted deployments are bounded only by the operator's own infrastructure and worker configuration.",
+        shortValue: 'Unknown, no published execution/concurrency limits',
+        confidence: 'unknown',
+        sources: [],
+      },
+      partialFailureHandling: {
+        value:
+          'Unknown: no public documentation describes routing a single failing step to an error-handling path while the rest of the flow continues; this was not confirmed as a native feature in the documentation reviewed.',
+        shortValue: 'Unknown, no documented per-step error-routing feature',
+        confidence: 'unknown',
+        sources: [],
+      },
+      unattendedExecution: {
+        value:
+          'Partial: when Langflow is deployed as a server, self-hosted via Docker/Kubernetes or on Langflow Cloud, triggered runs (webhook, API call, or external cron/Airflow calling the API) execute on that server with no dependency on any particular client device staying open. But Langflow can also be run as a desktop app, and a flow triggered through that installation depends on the desktop app process itself staying running on that machine, since there is no separate always-on server component in that deployment mode.',
+        detail:
+          'The dependency is on the chosen deployment mode: a Docker/Kubernetes/Cloud deployment behaves like Sim (server-side, client-independent), while the desktop app is a local process that must stay running to serve triggers.',
+        shortValue: 'Yes if server-deployed; desktop app requires that app to stay running',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/get-started-installation',
+            label: 'Langflow Docs: Install Langflow',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.langflow.org/webhook',
+            label: 'Langflow Docs: Trigger flows with webhooks',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    support: {
+      supportChannels: {
+        value:
+          "Langflow's primary support channel is a public Discord community server, plus GitHub Discussions and Issues for questions and feature requests. No official documentation confirms a paid or dedicated enterprise support tier separate from DataStax or IBM commercial channels.",
+        shortValue: 'Discord and GitHub community support; no confirmed paid tier',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/contributing-community',
+            label: 'Langflow Docs: Join the Langflow community',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      sla: {
+        value:
+          'Unknown: no public documentation confirms a formal SLA for response time or uptime guarantee offered for Langflow, on any plan.',
+        shortValue: 'Unknown, no SLA documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      community: {
+        value:
+          "Langflow's GitHub repository has approximately 150,700 stars and 9,395 forks, alongside an active public Discord server. Industry coverage frequently describes it as a widely used open-source AI-agent and RAG (retrieval-augmented generation) builder.",
+        shortValue: 'About 150,700 GitHub stars, 9,400 forks',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://github.com/langflow-ai/langflow',
+            label: 'GitHub: langflow-ai/langflow',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      companyMaturity: {
+        value:
+          "Langflow started as a self-funded startup called Logspace before DataStax acquired it in April 2024. DataStax, including Langflow, was then acquired by IBM as announced in February 2025, making Langflow part of IBM's watsonx portfolio.",
+        shortValue: 'Acquired by DataStax 2024, then folded into IBM 2025',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://techcrunch.com/2024/04/04/datastax-acquires-logspace-the-startup-behind-the-langflow-low-code-tool-for-building-rag-based-chatbots/',
+            label: 'TechCrunch: DataStax acquires Langflow (Logspace)',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://newsroom.ibm.com/2025-02-25-ibm-to-acquire-datastax,-deepening-watsonx-capabilities-and-addressing-generative-ai-data-needs-for-the-enterprise',
+            label: 'IBM Newsroom: IBM to acquire DataStax',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      academy: {
+        value:
+          "Unknown: Langflow doesn't run an official structured course, certification, or academy program. Third-party paid courses exist on platforms like Udemy that teach LangChain and Langflow, but these aren't an official Langflow product.",
+        shortValue: 'No official academy; only third-party courses found',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.udemy.com/course/langchain-masterclass/',
+            label: 'Udemy: Master LangChain with No-Code tools: Flowise and LangFlow',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+  },
+}

apps/sim/lib/compare/data/feature-catalog.ts

@@ -0,0 +1,905 @@
+import type { SimFeature } from '@/lib/compare/data/types'
+
+/**
+ * Sim's full feature catalog, sourced directly from the codebase (file paths
+ * as of the compare-pages-data worktree, checked 2026-07-02). This is a
+ * superset of {@link ComparisonFacts}. A page builder can filter this list
+ * by {@link SimFeature.category} or tag to assemble the subset relevant to
+ * a specific "Sim vs X" page, without re-deriving facts each time.
+ *
+ * Absence is recorded as honestly as presence: entries tagged "not-found"
+ * document a capability that was searched for and does not currently exist,
+ * so a future page builder doesn't have to re-verify it.
+ */
+export const SIM_FEATURES: SimFeature[] = [
+  // ---- deployment-api ----------------------------------------------------
+  {
+    id: 'deploy-versioned-rest-api',
+    name: 'Deploy a workflow as a versioned REST API',
+    category: 'deployment-api',
+    tags: ['api', 'enterprise'],
+    description:
+      'Workflows deploy/undeploy via POST/DELETE on /api/v1/workflows/[id]/deploy. Each deploy creates an immutable, numbered entry in a workflow_deployment_version table (state snapshot, isActive flag); executions, webhooks, and schedules all pin to the exact deployed version that ran, so draft edits never affect live traffic until redeployed. Rollback to a prior version is a first-class action.',
+    competitiveNote:
+      'The draft/deployed split with per-version execution pinning is more explicit than a simple "publish" toggle. Live traffic is isolated from in-progress edits by construction, not by convention.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/execution/api',
+        label: 'Sim Docs: External API',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/packages/db/schema.ts',
+        label: 'Sim codebase: workflow_deployment_version table',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'streaming-api-responses',
+    name: 'Streaming API responses (SSE)',
+    category: 'deployment-api',
+    tags: ['api'],
+    description:
+      'Workflow execution can stream over Server-Sent Events by passing a stream body param or X-Stream-Response header, returning stream:chunk/stream:done events. A separate reconnect/replay endpoint lets a client resume a stream from a given event id, backed by an event buffer, capped at 55 minutes. Agent-block responses stream per-provider through a shared StreamingExecution wrapper.',
+    competitiveNote:
+      'Streaming plus a resumable/replayable event buffer is a level of durability beyond a plain SSE passthrough. A dropped client connection does not lose the run.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/execution/api',
+        label: 'Sim Docs: External API',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/app/api/workflows/[id]/executions/[executionId]/stream/route.ts',
+        label: 'Sim codebase: stream reconnect/replay route',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'chat-deployment-surface',
+    name: 'Deploy a workflow as an embeddable public chat',
+    category: 'deployment-api',
+    tags: ['api'],
+    description:
+      'A chat_trigger block plus /api/chat routes let a workflow be deployed as a public or gated (password/email/SSO) chat endpoint, addressable by a custom subdomain/identifier, independent of the REST API deployment.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/workflows/deployment/chat',
+        label: 'Sim Docs - Chat Deployment',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/workflows/deployment/chat',
+        label: 'Sim Docs - Chat Deployment',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'inbound-webhook-trigger',
+    name: 'Generic inbound webhook trigger',
+    category: 'deployment-api',
+    tags: ['api'],
+    description:
+      'A generic_webhook trigger accepts any HTTP method with optional Bearer/header auth, payload-path-based idempotency (7-day dedup window), and configurable response mode/status/body. Usable without a pre-built app-specific integration.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/triggers/webhook',
+        label: 'Sim Docs: Webhook Trigger',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'api-key-auth-and-rate-limiting',
+    name: 'API-key auth with plan-based rate limiting',
+    category: 'deployment-api',
+    tags: ['api', 'enterprise'],
+    description:
+      'The public v1 API authenticates via an x-api-key header (personal or workspace-scoped keys); workspace-scoped keys are restricted to their workspace, and personal keys can be disabled per-workspace. Rate limits are keyed by subscription plan and per-endpoint, with standard X-RateLimit-* headers and 429/Retry-After on exceed.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/api-reference/authentication',
+        label: 'Sim Docs: API Authentication',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/execution/api',
+        label: 'Sim Docs: External API (rate limits)',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'official-sdk',
+    name: 'Official client SDK',
+    category: 'deployment-api',
+    tags: ['not-found'],
+    description:
+      'No official JS/Python (or other language) client SDK exists in the repo or as a published package. The public API is REST-only, consumed via a plain x-api-key header. This is recorded as an honest gap, not inferred.',
+    sources: [],
+  },
+
+  // ---- human-in-the-loop --------------------------------------------------
+  {
+    id: 'human-in-the-loop-approval-block',
+    name: 'Human-in-the-loop approval block',
+    category: 'human-in-the-loop',
+    tags: ['enterprise'],
+    description:
+      'A dedicated human_in_the_loop block pauses workflow execution and waits for a human to submit a "Resume Form," with configurable display data and notification tool calls (e.g. Slack, email) fired on pause. A separate wait block supports plain time-based pauses (in-process ≤5 min, or a persisted async pause ≤30 days) without requiring human input.',
+    competitiveNote:
+      'This is a first-class, deeply implemented capability, not a workaround built from generic wait/poll nodes.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/blocks/human-in-the-loop',
+        label: 'Sim Docs: Human in the Loop Block',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'durable-pause-resume-execution',
+    name: 'Durable pause/resume via execution snapshots',
+    category: 'human-in-the-loop',
+    tags: ['enterprise'],
+    description:
+      'Paused runs persist their full execution state (ExecutionSnapshot) to the database, independent of any third-party durable-execution service. Resume happens via a public per-execution resume URL (API + UI), supporting sync, streaming, or async job-queue-dispatched resume; an approver opens a link (surfaced via the notification tool call) rather than needing product access.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/executor/execution/snapshot.ts',
+        label: 'Sim codebase: execution snapshot serializer',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/blocks/human-in-the-loop',
+        label: 'Sim Docs - Human-in-the-Loop Block',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+
+  // ---- enterprise-governance ----------------------------------------------
+  {
+    id: 'sso-saml-oidc',
+    name: 'SSO (SAML and OIDC)',
+    category: 'enterprise-governance',
+    tags: ['enterprise', 'security'],
+    description:
+      "SSO is implemented via better-auth's sso plugin, supporting both SAML and OIDC configs per provider. Registration requires an Enterprise-plan org, org owner/admin role, and DNS-validated domain ownership (no cross-org domain squatting). Self-hostable via an SSO_ENABLED flag, independent of the hosted Enterprise-plan gate.",
+    sources: [
+      {
+        url: 'https://docs.sim.ai/platform/enterprise/sso',
+        label: 'Sim Docs: Single Sign-On (SSO)',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/platform/enterprise/sso',
+        label: 'Sim Docs - Single Sign-On (SSO)',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'scim-directory-sync',
+    name: 'SCIM / automated directory sync',
+    category: 'enterprise-governance',
+    tags: ['not-found'],
+    description:
+      'No SCIM table, route, or plugin exists. User provisioning is invite-based only. There is no automated push-provisioning from an identity provider (e.g. Okta/Azure AD SCIM).',
+    sources: [],
+  },
+  {
+    id: 'org-admin-console',
+    name: 'Org-level team management console',
+    category: 'enterprise-governance',
+    tags: ['enterprise'],
+    description:
+      'Org owner/admins manage seats, invite/remove members, transfer ownership, and view billing in a Team Management settings surface. Roles are binary (admin/member) at the team level. There is no granular custom-role RBAC beyond that.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/permissions/roles-and-permissions',
+        label: 'Sim Docs: Roles and Permissions',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'per-member-usage-limits',
+    name: 'Org-pooled and per-member usage limits',
+    category: 'enterprise-governance',
+    tags: ['enterprise'],
+    description:
+      'Usage governance supports both an org-level pooled cap (organization.orgUsageLimit) and individual per-member overrides (organizationMemberUsageLimit, keyed by org+user, with an auditable setBy field recording which admin set the limit).',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/packages/db/schema.ts',
+        label: 'Sim codebase: orgUsageLimit / organizationMemberUsageLimit',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'audit-log-siem-export',
+    name: 'Audit logging with SIEM/warehouse export',
+    category: 'enterprise-governance',
+    tags: ['enterprise', 'security'],
+    description:
+      'A customer-facing audit-logs API (org admin/owner + active Enterprise plan required) supports filtering by action/resource/actor/date range with cursor pagination. Beyond in-product viewing, a generic "data drains" dispatcher can continuously stream audit logs (and workflow logs) to Datadog, S3, GCS, Azure Blob, BigQuery, Snowflake, or a generic webhook, with encryption at rest.',
+    competitiveNote:
+      'Continuous SIEM/warehouse export across six destination types is materially deeper than a downloadable CSV export.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/enterprise/audit-logs',
+        label: 'Sim Docs: Audit Logs',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/platform/enterprise/data-drains',
+        label: 'Sim Docs: Data Drains',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'admin-api-self-hosted-gitops',
+    name: 'Separate admin API for self-hosted GitOps',
+    category: 'enterprise-governance',
+    tags: ['enterprise', 'self-hosted'],
+    description:
+      'A distinct /api/v1/admin/** surface (organizations, users, workspaces, subscriptions, credits, audit logs, workflows, folders, access control) is authenticated by a static ADMIN_API_KEY header rather than a user session, explicitly documented for self-hosted GitOps/scripting rather than interactive use.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/platform/enterprise',
+        label: 'Sim Docs: Enterprise Admin API (x-admin-key)',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'environment-promotion',
+    name: 'Dev/staging/prod environment promotion',
+    category: 'enterprise-governance',
+    tags: ['not-found'],
+    description:
+      'No customer-facing deployment-environment concept (separate staging/prod deploy targets) exists. What does exist is versioned deploy/rollback of a single workflow (see deploy-versioned-rest-api) and per-user/per-workspace encrypted environment variable stores, which are secret stores, not deployment stages.',
+    sources: [],
+  },
+
+  // ---- knowledge-base-search -----------------------------------------------
+  {
+    id: 'kb-connector-live-sync',
+    name: '51 knowledge-base source connectors with recurring sync',
+    category: 'knowledge-base-search',
+    tags: ['integrations'],
+    description:
+      'Knowledge bases can sync documents from 51 external source connectors (including Google Drive, Notion, Confluence, SharePoint, S3, Slack, Salesforce, HubSpot, Jira, GitHub, Zendesk, and more). Sync is interval-based and recurring, not one-time import, via a syncIntervalMinutes/nextSyncAt schedule (default daily) polled by a cron endpoint every 5 minutes, with a per-run sync log (docs added/updated/deleted/failed) and stale-lock recovery. Manual on-demand re-sync is also supported. No push/webhook-driven re-sync (e.g. Drive change notifications) was found. The mechanism is polling-based.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/connectors/registry.ts',
+        label: 'Sim codebase: connector registry (51 connectors)',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/knowledgebase/connectors',
+        label: 'Sim Docs - Knowledge Base Connectors',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'kb-hybrid-search',
+    name: 'Hybrid semantic + keyword knowledge-base search',
+    category: 'knowledge-base-search',
+    tags: [],
+    description:
+      'Knowledge base search combines pgvector embedding similarity with a generated tsvector full-text index; searching across knowledge bases with different embedding models is explicitly blocked to avoid meaningless cross-model comparisons.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/tools/knowledge',
+        label: 'Sim Docs - Knowledge Base Tool',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'global-product-search',
+    name: 'Unified cross-entity global search',
+    category: 'knowledge-base-search',
+    tags: ['not-found'],
+    description:
+      'No single search spans workflows, execution logs, files, and knowledge bases together. What exists is a command-palette-style search modal scoped to blocks/tools/tool-operations/triggers/docs (for building workflows), plus separate page-local filters on Logs and Files.',
+    sources: [],
+  },
+
+  // ---- data-tables ---------------------------------------------------------
+  {
+    id: 'tables-builtin-database',
+    name: 'Tables: a built-in database module',
+    category: 'data-tables',
+    tags: ['data'],
+    description:
+      'Tables store rows as flexible JSONB documents against a per-table JSON column schema (not fixed per-user Postgres tables), with fractional ordering keys and a GIN(jsonb_path_ops) index for containment queries. A REST API (internal and public v1) covers rows, columns, CSV import/export, and bulk jobs; a Table workflow block supports query/insert/upsert/update/delete/get-row/get-schema operations, and tables can themselves trigger workflow runs on new rows.',
+    competitiveNote:
+      'Column types are simple (no spreadsheet-style formula/computed-column engine); "enrichment" is LLM-driven per-row/per-column-group enrichment, not formulas.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/packages/db/schema.ts',
+        label: 'Sim codebase: userTableDefinitions/userTableRows',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/integrations/table',
+        label: 'Sim Docs: Table integration',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'tables-llm-enrichment',
+    name: 'LLM-driven row/column enrichment',
+    category: 'data-tables',
+    tags: ['ai'],
+    description:
+      'Tables support per-row enrichment via LLM-backed "column groups". An enrichment run populates cells using an LLM given the row and column context, distinct from static spreadsheet formulas.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/lib/copilot/tools/server/enrichment/enrichment-run.ts',
+        label: 'Sim codebase: table enrichment run',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+
+  // ---- files -----------------------------------------------------------------
+  {
+    id: 'files-shared-team-store',
+    name: 'Shared, workspace-scoped file store',
+    category: 'files',
+    tags: ['data'],
+    description:
+      'Files are stored in a genuinely shared, workspace-scoped store (not per-user), with nested folders and soft delete. A REST API (internal and public v1) covers upload/serve/manage. A File workflow block reads, writes, appends, fetches, compresses/decompresses, and manages sharing for files as workflow inputs or outputs.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/packages/db/schema.ts',
+        label: 'Sim codebase: workspaceFile/workspaceFileFolder',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/tools/file',
+        label: 'Sim Docs: File Tool',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'files-rich-viewers',
+    name: 'Rich in-app file viewers and editors',
+    category: 'files',
+    tags: [],
+    description:
+      'The Files module renders CSV, XLSX, PDF, DOCX, PPTX (sandboxed), images, Mermaid diagrams, and plain text/code inline, plus a dedicated rich WYSIWYG Markdown editor (not just a preview) for editing Markdown files in place.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/files',
+        label: 'Sim Docs: Files',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'copilot-virtual-filesystem',
+    name: 'Copilot virtual filesystem (VFS)',
+    category: 'files',
+    tags: ['ai'],
+    description:
+      "A distinct in-memory virtual filesystem abstraction lets the Copilot agent browse workspace resources (workflows, tables, docs) as file-like paths/tools. It reads from the Files module and table data but is a separate concept from a user's actual file store.",
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/tree/main/apps/sim/lib/copilot/vfs/',
+        label: 'Sim codebase: copilot VFS',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+
+  // ---- environments-enterprise (workspace forking / dev-qa-prod promote) ----
+  {
+    id: 'workspace-fork-promote',
+    name: 'Fork a workspace and promote changes between environments',
+    category: 'environments-enterprise',
+    tags: ['enterprise', 'flagship'],
+    description:
+      'A whole workspace (not a single workflow) can be forked to create a dev/qa/prod-style child environment. Deployed workflows are cloned into the child (left undeployed there), with an optional copy of files, tables, knowledge bases, custom tools, skills, and MCP server configs. Changes can then be synced bidirectionally between the parent and child ("promote": push parent→child or pull child→parent), with a diff preview before applying and a stored snapshot enabling one-level rollback of each promote run.',
+    competitiveNote:
+      'This is a genuine git-like fork/diff/promote/rollback system scoped to an entire workspace, not a single-workflow versioning feature. Most workflow-automation competitors only version individual workflows, not whole environments with cross-environment resource remapping.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/platform/enterprise/forks',
+        label: 'Sim Docs: Workspace Forks',
+        asOf: '2026-07-08',
+      },
+    ],
+  },
+  {
+    id: 'fork-credential-remapping',
+    name: 'Per-environment credential and env-var remapping on promote',
+    category: 'environments-enterprise',
+    tags: ['enterprise', 'security', 'flagship'],
+    description:
+      "Forking never copies credentials. All credential references are cleared in the child workspace at creation time. Instead, an admin explicitly maps each source OAuth/service-account credential to the target workspace's own credential via a dedicated mapping UI/API before promoting; environment variables remap by name (including rewriting {{ENV_KEY}} references inside copied custom-tool code or MCP headers if renamed, e.g. SLACK_API_KEY → SLACK_API_KEY_TEST). Credential and env-var mappings are required. An unmapped one blocks the promote rather than silently syncing a secret across environments, while optional resources (knowledge bases, tables, files, MCP servers) clear gracefully if unmapped.",
+    competitiveNote:
+      'Treating credentials/env-vars as required-and-blocking on promote (rather than silently copying secrets) is a specific, auditable safety design for enterprise dev→qa→prod pipelines.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/platform/enterprise/forks',
+        label: 'Sim Docs: Workspace Forks (mappings)',
+        asOf: '2026-07-08',
+      },
+    ],
+  },
+  {
+    id: 'fork-enterprise-gating',
+    name: 'Workspace forking gated to Enterprise plan (or self-hosted flag)',
+    category: 'environments-enterprise',
+    tags: ['enterprise'],
+    description:
+      'Forking/promotion is gated on the billed account having Enterprise-tier access on hosted Sim, mirroring the same access-gate pattern used for SSO. Self-hosted deployments can enable it independent of billing via a FORKING_ENABLED/NEXT_PUBLIC_FORKING_ENABLED environment flag.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/platform/enterprise/forks',
+        label: 'Sim Docs: Workspace Forks (self-hosted setup)',
+        asOf: '2026-07-08',
+      },
+    ],
+  },
+
+  // ---- version-control ------------------------------------------------------
+  {
+    id: 'copilot-checkpoint-revert',
+    name: 'Server-persisted checkpoint/revert for AI-driven edits',
+    category: 'version-control',
+    tags: ['ai'],
+    description:
+      'Before and after each Copilot AI edit to a workflow, a full canvas-state snapshot is saved server-side (keyed by user/workflow/chat/message) and can be restored via a revert endpoint or browsed via a checkpoint list. This is real server-side point-in-time restore, but scoped to Copilot-driven sessions. Manual drag-and-drop edits are not autosaved server-side.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/packages/db/schema.ts',
+        label: 'Sim codebase: workflowCheckpoints table',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/app/api/copilot/checkpoints/revert/route.ts',
+        label: 'Sim codebase: checkpoint revert API',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'ai-edit-visual-diff',
+    name: 'Visual diff with accept/reject for AI-proposed changes',
+    category: 'version-control',
+    tags: ['ai'],
+    description:
+      'A dedicated diff engine computes added/edited/deleted blocks and edges (plus field-level diffs) between the live workflow and a Copilot-proposed change, rendered with an accept/reject UI before the change is applied. This diff view is scoped to Copilot-proposed edits vs. the current baseline. There is no user-facing tool to diff two arbitrary past deployment versions against each other.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/lib/workflows/diff/diff-engine.ts',
+        label: 'Sim codebase: WorkflowDiffEngine',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'manual-edit-history',
+    name: 'Persisted history for manual (non-AI) canvas edits',
+    category: 'version-control',
+    tags: ['not-found'],
+    description:
+      'Undo/redo for manual drag-and-drop editing is client-side only (localStorage-persisted, capped at 100 ops / 5 stacks per browser). It is not synced across devices or recoverable server-side. There is no autosave history timeline or arbitrary-version diff/compare tool for manual edits, and no per-workflow git-like branch/merge model (only the workspace-level fork/promote system, cataloged separately). Knowledge base documents have no version/history tracking at all.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/stores/undo-redo/store.ts',
+        label: 'Sim codebase: client-side undo/redo store',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+
+  // ---- durability-observability ---------------------------------------------
+  {
+    id: 'otel-telemetry',
+    name: 'OpenTelemetry-instrumented execution telemetry',
+    category: 'durability-observability',
+    tags: [],
+    description:
+      'Sim ships real OpenTelemetry instrumentation (NodeSDK, batched OTLP trace/metric export, sampling) covering generative-AI, copilot, and tool-execution spans. This is aimed at product/ops-level observability (togglable by the user, and disableable via NEXT_TELEMETRY_DISABLED) rather than a customer-facing per-execution trace-waterfall UI inside the product. Block-level execution timing is tracked via start/end timestamps on execution logs, not an exposed span tree.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/instrumentation-node.ts',
+        label: 'Sim codebase: OTel NodeSDK setup',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'execution-stats-dashboard',
+    name: 'Aggregate execution stats (success rate, avg duration)',
+    category: 'durability-observability',
+    tags: [],
+    description:
+      'A stats API buckets execution logs into time segments and returns total/successful/failed execution counts, average duration, and overall success rate per workflow and in aggregate. This covers averages and error-rate only. There is no p50/p95/p99 latency percentile view or a dedicated cost-over-time chart in this endpoint.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/execution/logging',
+        label: 'Sim Docs - Logging',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'workspace-event-trigger-for-alerting',
+    name: 'Build custom failure/cost-spike alerting via a workspace-event trigger',
+    category: 'durability-observability',
+    tags: [],
+    description:
+      "There is no turnkey 'email me when a run fails' checkbox. Instead, a sim_workspace_event trigger fires on Sim's own platform events (run success/failure, deployments, cost/latency spikes), which a user can wire to any notification block (Slack, email, generic webhook, SMTP) to build custom alerting. The primitive exists, but it is build-it-yourself, not a pre-built alert rule UI.",
+    sources: [
+      {
+        url: 'https://docs.sim.ai/workflows/triggers/sim',
+        label: 'Sim Docs: Sim Workspace Events trigger',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'deliberate-no-auto-retry',
+    name: 'Deliberate no-automatic-retry execution model',
+    category: 'durability-observability',
+    tags: [],
+    description:
+      "Background job retries are explicitly disabled at the infrastructure layer (maxAttempts: 1) by design; durability instead comes from app-level bookkeeping. Scheduled executions track consecutive infrastructure-failure counts and auto-disable a schedule after a threshold, distinguishing infra failures from business-logic failures. There is no automatic block-level retry loop, no idempotency-key-based exactly-once block execution, no dead-letter queue for failed runs, and no 'replay a past execution with its original inputs' feature. The only checkpoint/resume path is the human-in-the-loop pause/resume mechanism (cataloged separately).",
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/trigger.config.ts',
+        label: 'Sim codebase: retries.default.maxAttempts = 1',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/triggers/schedule',
+        label: 'Sim Docs: Schedule Trigger (Automatic Disabling)',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'per-model-call-cost-attribution',
+    name: 'Cost/token tracking per model-call event',
+    category: 'durability-observability',
+    tags: [],
+    description:
+      'Usage log rows carry execution/workflow/workspace IDs plus input/output token counts and tool cost, categorized as model/fixed/tool spend, giving cost attribution per model-call event within an execution. This approximates per-block cost for single-call agent blocks, but attribution below the model-call level (e.g. disambiguating multiple tool calls inside one agent block) is not confirmed as a distinct column.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/execution/logging',
+        label: 'Sim Docs: Logging',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+
+  // ---- generative-media -------------------------------------------------------
+  {
+    id: 'image-generation-multi-provider',
+    name: 'Image generation across 4 provider families',
+    category: 'generative-media',
+    tags: ['ai'],
+    description:
+      "A dedicated Image Generator block supports OpenAI (GPT Image 1.5/1/1 Mini, DALL-E 3), Google Gemini 'Nano Banana' image models, and (via a Fal.ai multi-model proxy) Nano Banana 2/Pro, Seedream 4.5, FLUX 2 Pro, and Grok Imagine Image. Stability AI, Midjourney, Ideogram, and Recraft are not integrated.",
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/blocks/blocks/image_generator.ts',
+        label: 'Sim codebase: Image Generator V2 block',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'video-generation-multi-provider',
+    name: 'Video generation across 5+ provider families',
+    category: 'generative-media',
+    tags: ['ai'],
+    description:
+      'A dedicated Video Generator block supports Runway Gen-4, Google Veo (3 / 3 Fast / 3.1 / 3.1 Fast), Luma Dream Machine (Ray 2), MiniMax Hailuo (2.3 / 02), and (via a Fal.ai multi-model proxy) Sora 2 / Sora 2 Pro, ByteDance Seedance 2.0, Kling (3.0 Pro/4K, O3 Pro/4K, 2.5/2.1 Turbo Pro), WAN 2.1/2.2, and LTX-family models. HeyGen and Pika are not integrated.',
+    competitiveNote:
+      'Depth here (5+ first-party providers plus a multi-model proxy spanning a dozen more video models) is unusually broad for a workflow-automation platform. This is typically the domain of dedicated media-gen tools, not general automation builders.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/blocks/blocks/video_generator.ts',
+        label: 'Sim codebase: Video Generator V3 block',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'text-to-speech-multi-provider',
+    name: 'Text-to-speech across 7 provider families',
+    category: 'generative-media',
+    tags: ['ai'],
+    description:
+      'A dedicated TTS block supports OpenAI TTS, Deepgram Aura, ElevenLabs, Cartesia Sonic, Google Cloud TTS, Azure TTS, and PlayHT. A separate dedicated ElevenLabs block additionally covers sound effects, speech-to-speech, and audio isolation.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/blocks/blocks/tts.ts',
+        label: 'Sim codebase: TTS block',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'speech-to-text-multi-provider',
+    name: 'Speech-to-text across 5 provider families',
+    category: 'generative-media',
+    tags: ['ai'],
+    description:
+      'A dedicated STT block supports OpenAI Whisper, Deepgram (Nova 3/2/Whisper Large), ElevenLabs Scribe, AssemblyAI, and Google Gemini transcription variants.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/blocks/blocks/stt.ts',
+        label: 'Sim codebase: STT block',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+
+  // ---- control-flow-execution ---------------------------------------------------
+  {
+    id: 'control-flow-primitives',
+    name: 'Conditional branching, LLM-based routing, loops, and parallel execution',
+    category: 'control-flow-execution',
+    tags: [],
+    description:
+      'Beyond simple if/else (Condition block), a Router block lets an LLM semantically pick the next path among candidate downstream blocks rather than evaluating a boolean. Loop and Parallel are canvas subflow containers (not single blocks) supporting for-each/while-style iteration and concurrent fan-out branching, respectively.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/workflows/blocks/router',
+        label: 'Sim Docs: Router block',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/blocks/loop',
+        label: 'Sim Docs: Loop Block',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'nested-sub-workflow-invocation',
+    name: 'Invoke another workflow as a step (nested sub-workflows)',
+    category: 'control-flow-execution',
+    tags: [],
+    description:
+      "A Workflow block lets one Sim workflow call another as a single step, passing an input variable exposed as the child's start input, enabling composable, reusable sub-workflows.",
+    sources: [
+      {
+        url: 'https://docs.sim.ai/workflows/blocks/workflow',
+        label: 'Sim Docs: Workflow (sub-workflow) block',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'sandboxed-code-execution',
+    name: 'Sandboxed JavaScript and Python code execution',
+    category: 'control-flow-execution',
+    tags: [],
+    description:
+      'A Function block runs arbitrary code: import-free JavaScript executes in a fast local VM, while JavaScript with imports and all Python execute in a remote E2B sandbox using dedicated templates (including one with python-pptx/docx/openpyxl/reportlab preinstalled for document generation).',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/blocks/function',
+        label: 'Sim Docs: Function Block',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'browser-automation-blocks',
+    name: 'Browser automation and web scraping (multiple engines)',
+    category: 'control-flow-execution',
+    tags: [],
+    description:
+      'Dedicated blocks cover natural-language browser automation (Browser Use: navigate + act), structured or agentic web extraction (Stagehand), and full crawl/scrape/map/extract operations (Firecrawl), alongside additional named scraping/search integrations (Apify, Bright Data, Linkup, Jina).',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/tools/browser_use',
+        label: 'Sim Docs: Browser Use Integration',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/tools/firecrawl',
+        label: 'Sim Docs: Firecrawl Integration',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'guardrails-and-evaluator-blocks',
+    name: 'Guardrails and LLM-judge evaluator blocks',
+    category: 'control-flow-execution',
+    tags: [],
+    description:
+      'A Guardrails block covers JSON-validity checks, regex validation, RAG/hallucination scoring (0-10 with reasoning), and PII detection/masking. An Evaluator block scores content against user-defined named metrics via an LLM judge. These are per-call scoring/validation primitives. There is no batch golden-dataset eval-suite runner or A/B prompt-testing harness in the block library.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/blocks/guardrails',
+        label: 'Sim Docs: Guardrails Block',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/blocks/evaluator',
+        label: 'Sim Docs: Evaluator Block',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'memory-and-variable-blocks',
+    name: 'Cross-turn memory and workflow-scoped variables',
+    category: 'control-flow-execution',
+    tags: [],
+    description:
+      'A Memory block stores/retrieves records keyed by conversation ID for injecting artificial memory into agent blocks (which also have native memory modes of their own). A Variables block provides a workflow-scoped variable store shared across Variables blocks within a single run (not persisted across separate runs). Third-party Mem0 and Zep memory-service integrations are also available as blocks.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/integrations/memory',
+        label: 'Sim Docs: Memory integration',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/workflows/blocks/variables',
+        label: 'Sim Docs: Variables block',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'agent-to-agent-interop',
+    name: 'Agent-to-Agent (A2A) protocol client',
+    category: 'control-flow-execution',
+    tags: [],
+    description:
+      "An A2A block lets a Sim workflow act as a client to any Agent-to-Agent-protocol-compliant external agent: send a message, get/cancel a task, and fetch the remote agent's Agent Card. This is distinct from MCP (tool-calling protocol). A2A is agent-to-agent messaging.",
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/blocks/blocks/a2a.ts',
+        label: 'Sim codebase: A2A block',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+
+  // ---- enterprise-governance (permission groups, follow-up findings) --------
+  {
+    id: 'permission-group-model-and-tool-governance',
+    name: 'Permission groups: per-role model and tool allow/deny lists',
+    category: 'enterprise-governance',
+    tags: ['enterprise', 'security'],
+    description:
+      'Beyond workspace-level admin/write/read roles, an Enterprise "permission group" config can allow-list or deny-list specific LLM providers/models a role may use, and separately deny specific tools/integrations (or disable all MCP or custom tools) for that role. E.g. allow Slack but deny Salesforce, or allow OpenAI but deny a specific Ollama model. Enforced server-side at execution time (agent, evaluator, and router blocks), not just in the UI.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/permissions/roles-and-permissions',
+        label: 'Sim Docs: Roles and Permissions',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://docs.sim.ai/permissions/roles-and-permissions',
+        label: 'Sim Docs: Roles and Permissions',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'log-retention-window-and-pii-redaction',
+    name: 'Configurable log-retention window with PII redaction',
+    category: 'enterprise-governance',
+    tags: ['enterprise', 'security'],
+    description:
+      'An Enterprise-gated feature lets an org configure how long execution logs are retained and enable Presidio-based redaction of PII from logged inputs/outputs. This is a log-retention/redaction policy, not a "zero data retention" mode for LLM providers. It does not affect whether a model provider itself retains prompts.',
+    sources: [
+      {
+        url: 'https://docs.sim.ai/platform/enterprise',
+        label: 'Sim Docs: Enterprise (Data Retention)',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'zero-data-retention-llm-mode',
+    name: 'Zero-data-retention (ZDR) mode for LLM calls',
+    category: 'enterprise-governance',
+    tags: ['not-found'],
+    description:
+      'No "zero data retention" or "incognito" mode exists for how Sim itself handles LLM requests (i.e. no documented ZDR agreements with model providers, no request-level opt-out of provider-side retention). The only genuine ZDR references in the codebase describe a competitor\'s offering in this same comparison dataset.',
+    sources: [],
+  },
+  {
+    id: 'ai-gateway-proxy-routing',
+    name: 'Governed AI request proxy/gateway',
+    category: 'enterprise-governance',
+    tags: ['not-found'],
+    description:
+      "Model calls go directly from the execution environment to each provider's API (after a permission-group pre-call gate), not through a dedicated policy-enforcing AI gateway/proxy layer.",
+    sources: [],
+  },
+  {
+    id: 'dynamic-agent-tool-discovery',
+    name: 'Dynamic (browse-and-pick) tool use by agents',
+    category: 'ai-capabilities',
+    tags: ['not-found'],
+    description:
+      'An Agent block can only call tools the workflow author explicitly attached to it at build time. It cannot browse and choose from a broader pool (e.g. an MCP server\'s full tool catalog, or "every tool in the workspace") at inference time. Runtime MCP discovery exists but only refreshes the schema of an already-configured tool.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/executor/handlers/agent/agent-handler.ts',
+        label: 'Sim codebase: agent tool resolution (pre-wired only)',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'automatic-model-fallback',
+    name: 'Automatic LLM model/provider fallback',
+    category: 'ai-capabilities',
+    tags: ['not-found'],
+    description:
+      'A failed or rate-limited LLM call is not automatically retried against a different model or provider; the error is thrown rather than retried with a fallback model.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/providers/index.ts',
+        label: 'Sim codebase: executeProviderRequest (no retry/fallback)',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+
+  // ---- files (artifact generation, follow-up findings) -----------------------
+  {
+    id: 'copilot-document-artifact-generation',
+    name: 'Copilot-generated document artifacts (decks, docs, spreadsheets)',
+    category: 'files',
+    tags: [],
+    description:
+      'Copilot has an internal document-compilation tool that runs Python (python-pptx/python-docx/openpyxl) or Node (pptxgenjs/docx) in a dedicated E2B sandbox to produce real .pptx/.docx/.xlsx binaries, content-addressed and served back to the user.',
+    competitiveNote:
+      'This capability is scoped to Copilot\'s own chat-assistant tool. It is not exposed as a configurable option in the workflow-builder Function block, so a workflow author cannot wire "generate a slide deck" into a reusable automation today, only ask Copilot for one interactively.',
+    sources: [
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/lib/copilot/tools/server/files/doc-compile.ts',
+        label: 'Sim codebase: Copilot doc-compile tool',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    id: 'workflow-builder-artifact-generation',
+    name: 'Workflow-author-facing artifact generation (decks/docs from a workflow step)',
+    category: 'files',
+    tags: ['not-found'],
+    description:
+      'The canvas Function/code block does not expose the pptx/docx/xlsx-capable sandbox template, and there is no first-class "artifact" object (with versioning) anywhere in the codebase. Generating a shareable, versioned document from an ordinary workflow step is not currently possible outside asking Copilot directly.',
+    sources: [],
+  },
+  {
+    id: 'native-end-user-forms',
+    name: 'Native end-user input forms (non-chat trigger surface)',
+    category: 'deployment-api',
+    tags: ['not-found'],
+    description:
+      'There is no Sim-native "Forms" builder. A simple field-based input form a non-technical person fills out to trigger a workflow, distinct from the chat or API surfaces. Only third-party form integrations (Google Forms, Typeform, JSM forms) exist, which consume external form services rather than hosting a form within Sim.',
+    sources: [],
+  },
+]

apps/sim/lib/compare/data/index.ts

@@ -0,0 +1,32 @@
+export { claudeCoworkProfile } from '@/lib/compare/data/competitors/claude-cowork'
+export { crewaiProfile } from '@/lib/compare/data/competitors/crewai'
+export { dustProfile } from '@/lib/compare/data/competitors/dust'
+export { flowiseProfile } from '@/lib/compare/data/competitors/flowise'
+export { gumloopProfile } from '@/lib/compare/data/competitors/gumloop'
+export { langchainProfile } from '@/lib/compare/data/competitors/langchain'
+export { langflowProfile } from '@/lib/compare/data/competitors/langflow'
+export { makeProfile } from '@/lib/compare/data/competitors/make'
+export { microsoftCopilotProfile } from '@/lib/compare/data/competitors/microsoft-copilot'
+export { n8nProfile } from '@/lib/compare/data/competitors/n8n'
+export { openaiAgentkitProfile } from '@/lib/compare/data/competitors/openai-agentkit'
+export { openClawProfile } from '@/lib/compare/data/competitors/openclaw'
+export { pipedreamProfile } from '@/lib/compare/data/competitors/pipedream'
+export { powerAutomateProfile } from '@/lib/compare/data/competitors/power-automate'
+export { retoolProfile } from '@/lib/compare/data/competitors/retool'
+export { stackaiProfile } from '@/lib/compare/data/competitors/stackai'
+export { tinesProfile } from '@/lib/compare/data/competitors/tines'
+export { vellumProfile } from '@/lib/compare/data/competitors/vellum'
+export { workatoProfile } from '@/lib/compare/data/competitors/workato'
+export { zapierProfile } from '@/lib/compare/data/competitors/zapier'
+export { SIM_FEATURES } from '@/lib/compare/data/feature-catalog'
+export { simProfile } from '@/lib/compare/data/sim'
+export type {
+  ComparisonFacts,
+  CompetitorBrand,
+  CompetitorProfile,
+  Fact,
+  FactSource,
+  FeatureCategory,
+  SimFeature,
+} from '@/lib/compare/data/types'
+export { featuresByCategory, featuresByTag } from '@/lib/compare/data/types'

apps/sim/lib/compare/data/types.ts

@@ -0,0 +1,300 @@
+/**
+ * Data model for "Sim vs {Competitor}" comparison pages.
+ *
+ * This module intentionally contains no UI. It is the data layer only.
+ * Every {@link Fact} carries a source so comparison claims can be audited
+ * before they are ever rendered. A page-rendering layer can be built on
+ * top of {@link CompetitorProfile} later without touching this schema.
+ */
+import type { ComponentType, SVGProps } from 'react'
+
+/** Where a fact came from, and when it was last checked. */
+export interface FactSource {
+  /** Publicly reachable URL that substantiates this fact (pricing page, docs, changelog, etc). */
+  url: string
+  /** Short human label for the source, e.g. "n8n Pricing page". */
+  label: string
+  /** ISO date (YYYY-MM-DD) the source was last checked. */
+  asOf: string
+}
+
+/** A single comparable data point (one cell in a comparison table row). */
+export interface Fact {
+  /** The value to display, already formatted for reading (e.g. "750 tasks/mo", "Yes", "$29.99/mo"). */
+  value: string
+  /**
+   * A compact, scannable restatement of `value` (roughly 3-10 words) for
+   * dense contexts like the comparison table and key-differences strip.
+   * Must not introduce any claim not already in `value`/`detail`. It is a
+   * compression of the same fact, not a new one. Falls back to `value` when
+   * absent.
+   */
+  shortValue?: string
+  /** Optional longer explanation shown on hover/expand. */
+  detail?: string
+  /** Whether this fact was corroborated against a live primary source or is a best-effort estimate. */
+  confidence: 'verified' | 'estimated' | 'unknown'
+  /** Primary sources backing this fact. Empty only when confidence is 'unknown'. */
+  sources: FactSource[]
+}
+
+/**
+ * Canonical fact keys shared by every competitor profile, grouped into the
+ * row categories used by comparison tables (mirrors the category grouping
+ * used by competitor "vs" pages: platform, AI capabilities, integrations,
+ * pricing, security/compliance, support).
+ */
+export interface ComparisonFacts {
+  platform: {
+    builderType: Fact
+    learningCurve: Fact
+    selfHostOption: Fact
+    deploymentOptions: Fact
+    templates: Fact
+    license: Fact
+    /** Dev/qa/prod-style environment promotion. Forking or cloning a full project/workspace and pushing/pulling changes between environments, not just versioning one workflow. */
+    environmentPromotion: Fact
+    /** History/versioning depth: deploy rollback, diff/compare views, undo/redo (client vs. server persisted), branching. */
+    versionControlDepth: Fact
+    /** Live concurrent multi-user editing of the same workflow/canvas (cursors, selections, synced operations), distinct from async sharing or file-level locking. */
+    realtimeCollaboration: Fact
+    /** A native file storage system with folder hierarchy, link-based sharing (with auth options like password/SSO), and deleted-item recovery, versus only per-block file handling. */
+    nativeFileStorage: Fact
+    /** A native spreadsheet-like data table feature (not an external DB connector), including row/column limits and spreadsheet keyboard navigation (arrow keys, copy-paste). */
+    dataTables: Fact
+    /** An inline rich-text/WYSIWYG markdown editor for documents stored in the platform, versus a plain textarea or raw-source view only. */
+    richTextEditor: Fact
+    /** Calling one saved workflow as a reusable step inside another workflow (composition/nesting), versus only being able to duplicate or manually re-wire the same logic per workflow. */
+    subWorkflows: Fact
+    /** Publishing a deployed workflow/flow as a reusable, named block with its own icon/inputs/outputs that appears in the block toolbar for other org members to drop into their own workflows, without needing access to the underlying flow — distinct from subWorkflows (same-author composition) and from custom code/tool blocks. */
+    customBlocks: Fact
+  }
+  aiCapabilities: {
+    multiLlmSupport: Fact
+    agentReasoningBlocks: Fact
+    naturalLanguageBuilding: Fact
+    knowledgeBaseRag: Fact
+    mcpSupport: Fact
+    evaluationGuardrails: Fact
+    /** A dedicated mechanism for a run to pause and wait on human approval/input mid-workflow, distinct from a plain delay/wait step. */
+    humanInTheLoop: Fact
+    /** Built-in image, video, and audio (TTS/STT) generation blocks/nodes, and which providers. */
+    generativeMedia: Fact
+    /** Whether an agent can dynamically browse and pick tools at inference time from a broad pool, vs. only calling tools the workflow author pre-wired into that step. */
+    dynamicToolUse: Fact
+    /** Whether a failed/rate-limited LLM call automatically retries against a different model or provider, vs. surfacing the failure. */
+    modelFallback: Fact
+    /** Reusable, named prompt/knowledge snippets a builder defines once and invokes by reference across agents, distinct from a one-off system prompt. */
+    agentSkills: Fact
+    /** A native, publicly deployable conversational chat surface for an agent, versus only a form/API/webhook deployment target. */
+    nativeChatDeployment: Fact
+    /** Whether knowledge-base search results and their debugging views expose individual chunk-level detail (chunk index/content), not just whole-document results. */
+    kbChunkVisibility: Fact
+    /** Native support for fanning a run out into multiple branches that execute concurrently and join back into a single result, versus sequential-only execution or manual workarounds. */
+    parallelExecution: Fact
+    /** Support for the Agent2Agent (A2A) protocol, the emerging open standard for one AI agent to discover and call another agent as a peer, distinct from ordinary MCP tool-calling. */
+    a2aProtocol: Fact
+    /** A dedicated for-each/while loop container that iterates a set of steps over a list or a fixed count, distinct from a Parallel block's concurrent fan-out. */
+    loopIteration: Fact
+  }
+  integrations: {
+    integrationCount: Fact
+    triggerTypes: Fact
+    customCodeSteps: Fact
+    apiPublishing: Fact
+    /** Official client SDKs, plugin/custom-node development kits, and a marketplace for community-built integrations. */
+    extensibilitySdk: Fact
+    /** Publishing a deployed workflow itself as a callable MCP server for external AI tools to consume, the reverse direction of ordinary MCP client support. */
+    mcpPublishing: Fact
+  }
+  pricing: {
+    pricingModel: Fact
+    entryPaidPlan: Fact
+    freeTier: Fact
+    byok: Fact
+  }
+  security: {
+    soc2: Fact
+    dataResidency: Fact
+    rbac: Fact
+    auditLogging: Fact
+    /** Compliance certifications beyond a bare SOC2 mention. HIPAA, ISO 27001, GDPR-specific attestations, PCI, FedRAMP, etc. */
+    additionalCompliance: Fact
+    /** Admin-configurable restrictions on which LLM providers/models members may use, and which specific tools/integrations a role can call. Finer-grained than plain workspace admin/write/read. */
+    modelAndToolGovernance: Fact
+    /** Restricting which specific stored credentials/connections a role or permission group may use, distinct from feature-level RBAC or integration-level allow/deny. */
+    credentialGovernance: Fact
+    /** Replacing vendor branding (logo, product name, theme colors) with the customer's own across the workspace/deployed-app UI. */
+    whiteLabeling: Fact
+    /** Org-configurable retention windows for execution logs, soft-deleted resources, and similar data, versus a fixed platform-wide default. */
+    dataRetention: Fact
+    /** Detecting and redacting/blocking PII (emails, SSNs, etc.) in workflow content or retained logs, distinct from generic output-validation guardrails. */
+    piiRedaction: Fact
+    /** SAML/OIDC single sign-on with organization auto-provisioning on first login. */
+    sso: Fact
+    /** Whether integrations/tools/skills come from a vetted first-party catalog authored and reviewed by the vendor, versus an open marketplace where any third party can publish and users install executable code from unvetted authors. */
+    thirdPartyVetting: Fact
+  }
+  /**
+   * Production-readiness signals that matter once feature parity is
+   * established: whether a customer can see what happened inside a run,
+   * whether the platform recovers from failure on its own, and whether a
+   * failed run is even visible without the user going to look for it.
+   */
+  observability: {
+    tracingDepth: Fact
+    /** Automatic retries, checkpointing, and replay of a past execution with its original inputs. */
+    durabilityModel: Fact
+    /** Being notified (not just able to look up) that a run failed or crossed a cost/latency threshold. */
+    failureAlerting: Fact
+    /** Continuously exporting execution/audit/usage data to an external destination (S3, BigQuery, Datadog, webhook, etc.), versus only viewing it in-product. */
+    dataDrains: Fact
+    /** Triggering a run to execute in the background and polling or otherwise checking back for its result later, versus only a synchronous request that blocks until the run finishes. */
+    asyncExecution: Fact
+    /** Concrete published or verified numbers for how long a single execution/request may run and how many can run concurrently, since long-running agent workflows commonly hit these ceilings in practice. */
+    executionLimits: Fact
+    /** Whether one failing step can be routed to an error-handling path so the rest of the run continues, versus a single failure always halting the entire execution. */
+    partialFailureHandling: Fact
+    /** Whether a scheduled or triggered run executes on a server with no dependency on a client device being open, awake, or connected, versus requiring a desktop app/session to remain active. */
+    unattendedExecution: Fact
+  }
+  support: {
+    supportChannels: Fact
+    sla: Fact
+    community: Fact
+    /** Founding year, funding/stage, or other market-maturity signal. Relevant because a newer vendor carries real switching risk for an enterprise buyer. */
+    companyMaturity: Fact
+    /** A structured learning resource (courses, certification, tutorials) beyond ad hoc docs/blog content. */
+    academy: Fact
+  }
+}
+
+/** Brand icon + colors for a competitor, sourced from a brand-intelligence lookup rather than the vendor's own docs. */
+export interface CompetitorBrand {
+  /** Icon component from @/components/icons rendering this competitor's logo. */
+  icon: ComponentType<SVGProps<SVGSVGElement>>
+  /**
+   * Whether `icon` already renders a full, self-contained brand-colored
+   * square (a fetched app-store-style icon) rather than a bare transparent
+   * glyph. Self-framed icons fill their tile edge-to-edge; non-self-framed
+   * icons render small and centered on a plain tile background.
+   */
+  selfFramed?: boolean
+  /** Brand hex colors, most prominent first. */
+  colors: string[]
+  /** Brand-intelligence-sourced company description. Distinct from {@link CompetitorProfile.oneLiner}, which is independently fact-checked; this is a secondary, unverified reference. */
+  description?: string
+  /** Industry / sub-industry classifications from the brand-intelligence source. */
+  industries?: string[]
+  /** Social profile links from the brand-intelligence source. */
+  socials?: Array<{ type: string; url: string }>
+  /** Where this brand data was sourced from (e.g. "Context.dev brand-intelligence API"). */
+  source: string
+  /** ISO date (YYYY-MM-DD) this brand data was looked up. */
+  asOf: string
+}
+
+/** One competitor (or Sim itself) as a comparable profile. */
+export interface CompetitorProfile {
+  /** kebab-case identifier, e.g. "n8n", "openai-agentkit". */
+  id: string
+  /** Display name, e.g. "n8n", "OpenAI AgentKit". */
+  name: string
+  /** Marketing website root, used as the default citation target. */
+  website: string
+  /** One-sentence, neutral description of what the product is. */
+  oneLiner: string
+  /**
+   * Whether this competitor is, categorically, a visual workflow/automation
+   * builder like Sim. Defaults to `true` when omitted. Set `false` for a
+   * product that isn't (an interactive desktop agent) or has documented
+   * ambiguity about its current platform identity, so comparison-page FAQs
+   * can ask a category-clarifying question instead of a peer feature-gap one.
+   */
+  isWorkflowBuilder?: boolean
+  /** Logo icon and brand colors, when available. */
+  brand?: CompetitorBrand
+  /** Free-text list of standout features, each independently sourced. */
+  standoutFeatures: Array<{
+    title: string
+    description: string
+    /** A one-sentence (<~18 word) restatement of `description` for dense card UIs. Falls back to `description` when absent. */
+    shortDescription?: string
+    source: FactSource
+  }>
+  /** Free-text list of documented gaps/limitations, each independently sourced. */
+  limitations: Array<{
+    title: string
+    description: string
+    /** A one-sentence (<~18 word) restatement of `description` for dense card UIs. Falls back to `description` when absent. */
+    shortDescription?: string
+    source: FactSource
+  }>
+  facts: ComparisonFacts
+}
+
+/** A fact awaiting verification. Used as an intermediate research artifact, never shipped. */
+export function unknownFact(reason?: string): Fact {
+  return {
+    value: 'Unknown',
+    detail: reason,
+    confidence: 'unknown',
+    sources: [],
+  }
+}
+
+/**
+ * Broad grouping for {@link SimFeature} entries. A single feature catalog
+ * entry belongs to exactly one category, but can carry additional
+ * {@link SimFeature.tags} for cross-cutting filtering (e.g. an "enterprise"
+ * tag on a feature that's primarily categorized as "security-compliance").
+ */
+export type FeatureCategory =
+  | 'deployment-api'
+  | 'human-in-the-loop'
+  | 'enterprise-governance'
+  | 'knowledge-base-search'
+  | 'data-tables'
+  | 'files'
+  | 'ai-capabilities'
+  | 'collaboration'
+  | 'observability'
+  | 'security-compliance'
+  | 'environments-enterprise'
+  | 'version-control'
+  | 'durability-observability'
+  | 'generative-media'
+  | 'control-flow-execution'
+
+/**
+ * One entry in Sim's full feature catalog. Deliberately more granular than
+ * {@link ComparisonFacts}, which only covers the small set of rows every
+ * competitor page needs. The catalog is the superset a page builder can
+ * filter down from (by category or tag) when a given "Sim vs X" page only
+ * wants to surface the features relevant to that competitor.
+ */
+export interface SimFeature {
+  /** kebab-case identifier, e.g. "streaming-api", "human-in-the-loop-approval". */
+  id: string
+  /** Display name, e.g. "Streaming API responses". */
+  name: string
+  category: FeatureCategory
+  /** Additional cross-cutting labels for filtering (e.g. "enterprise", "beta"). */
+  tags: string[]
+  /** Neutral, factual description of what the feature does. */
+  description: string
+  /** Optional note on why this is differentiated vs. the competitive landscape. Must stay factual, not promotional. */
+  competitiveNote?: string
+  sources: FactSource[]
+}
+
+export function featuresByCategory(
+  features: SimFeature[],
+  category: FeatureCategory
+): SimFeature[] {
+  return features.filter((f) => f.category === category)
+}
+
+export function featuresByTag(features: SimFeature[], tag: string): SimFeature[] {
+  return features.filter((f) => f.tags.includes(tag))
+}