feat(comparison): add Custom Blocks as a comparison-page fact

apps/sim/app/(landing)/comparison/comparison-sections.ts

@@ -70,6 +70,7 @@ export const COMPARISON_SECTIONS: ComparisonSectionDef[] = [
       { key: 'dataTables', label: 'Native data tables' },
       { key: 'richTextEditor', label: 'Rich-text document editor' },
       { key: 'subWorkflows', label: 'Sub-workflows (composition)' },
+      { key: 'customBlocks', label: 'Custom blocks (org-wide reuse)' },
     ],
   }),
   defineSection({

apps/sim/lib/compare/data/competitors/claude-cowork.ts

@@ -329,6 +329,26 @@ export const claudeCoworkProfile: CompetitorProfile = {
           },
         ],
       },
+      customBlocks: {
+        value:
+          "No: Claude Cowork has no visual workflow builder, so there is no completed workflow to publish as a reusable block. The closest adjacent capability is org-wide Skills sharing: a member enables 'Share with organization' on a Skill (a SKILL.md instruction file, optionally with reference docs/scripts), and it becomes available to everyone in Customize > Skills. Recipients can enable and use a shared Skill but cannot edit its contents.",
+        detail:
+          "This does not meet the bar of a published-workflow-as-block. A Skill is read-only prompt/instruction text Claude consults at runtime, not an encapsulated, deployed multi-step workflow with auto-derived inputs, hand-picked named outputs, and a hidden internal implementation that always tracks the source's latest version. Cowork Projects, the closest thing to a saved unit of work, explicitly do not support sharing for members of Team and Enterprise plans; separately, Anthropic notes projects are 'desktop-only and stored locally,' with no cloud sync.",
+        shortValue: 'No: no publish-workflow-as-block feature exists',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://support.claude.com/en/articles/13119606-provision-and-manage-skills-for-your-organization',
+            label: 'Provision and manage skills for your organization',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://support.claude.com/en/articles/14116274-organize-your-tasks-with-projects-in-claude-cowork',
+            label: 'Organize your tasks with projects in Claude Cowork',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
     },
     aiCapabilities: {
       multiLlmSupport: {

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

@@ -331,6 +331,32 @@ export const crewaiProfile: CompetitorProfile = {
           },
         ],
       },
+      customBlocks: {
+        value:
+          'No: no documented feature to publish a deployed crew/flow as an encapsulated, org-wide reusable block',
+        detail:
+          "CrewAI AMP's Tool Repository publishes individual custom Tools (single Python functions/classes wrapping an API) to a shared, permissioned catalog, not entire crews or flows. No CrewAI source describes taking a deployed crew or flow and publishing it as a named, iconed block that appears in a shared builder palette for other org members to drop into their own separate crews, with internals hidden and the block auto-tracking the source's latest deployed version. The closest pattern, wrapping a Crew's kickoff as a callable Tool for another Crew, is discussed only as a same-project code workaround in CrewAI's community forum, not a first-party, org-wide publish-as-block feature.",
+        shortValue:
+          'No, Tool Repository publishes single Tools, not published crews/flows as blocks',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.crewai.com/en/enterprise/guides/tool-repository',
+            label: 'Tool Repository - CrewAI Docs',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://docs.crewai.com/en/enterprise/features/crew-studio',
+            label: 'Crew Studio - CrewAI Docs',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://community.crewai.com/t/crew-method-as-tool/400',
+            label: 'Crew method as tool - CrewAI Community',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
     },
     aiCapabilities: {
       multiLlmSupport: {

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

@@ -337,6 +337,26 @@ export const dustProfile: CompetitorProfile = {
           },
         ],
       },
+      customBlocks: {
+        value:
+          'No: Dust has no way to publish an agent as a named, encapsulated block that appears in a shared builder toolbox for other users, with its internals hidden and the source kept in sync',
+        detail:
+          'The closest Dust feature is Skills, a reusable package of instructions, knowledge, and tools attached to multiple agents with edits auto-propagating, but Dust\'s own docs describe Skills as explicitly transparent rather than encapsulated: a read-only summary of every referenced instruction, tool, and knowledge source is shown to whoever authors it in the Skill Editor, not hidden behind an interface exposing only defined inputs/outputs. The separate "Run agent" tool (see subWorkflows) lets one agent call another saved agent, but that is picking an existing agent to call from a list, not publishing a workflow as a distinct, iconed block in a builder toolbox with only its inputs/outputs exposed.',
+        shortValue: 'No: Skills are transparent, not encapsulated; no publish-as-block toolbox',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.dust.tt/docs/skills',
+            label: 'Skills | Dust Docs',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://docs.dust.tt/docs/run-agent',
+            label: 'Run agent | Dust Docs',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
     },
     aiCapabilities: {
       multiLlmSupport: {

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

@@ -243,6 +243,26 @@ export const flowiseProfile: CompetitorProfile = {
           },
         ],
       },
+      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: {

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

@@ -334,6 +334,31 @@ export const gumloopProfile: CompetitorProfile = {
           },
         ],
       },
+      customBlocks: {
+        value:
+          'No: Gumloop has no feature that publishes an existing deployed workflow as an encapsulated, named block for the whole org to reuse. Subflows let a saved workflow be dropped into other flows as a node, but public docs describe this only as personal/same-project reuse, with no mention of hiding the subflow\'s internal steps or credentials, or of org-wide toolbar placement for other users. The one org-wide, block-like publishing surface Gumloop does have, the Custom Node Builder plus its "Node and Flow Library" Hub, is scoped to single AI-generated code nodes (wrapping an API or script), not a way to turn a multi-step visual workflow into a reusable block.',
+        detail:
+          "Gumloop's docs on Subflows describe only how to nest a saved workflow as a node with Input/Output nodes for parameters, with no documented mechanism for sharing that subflow node to other users, hiding its internal graph from them, or auto-propagating updates when the source workflow changes. Separately, docs.gumloop.com/core-concepts/node_and_flow_library confirms users can share a Custom Node organization-wide ('Share with Organization: Makes the node discoverable by all organization members'), appearing immediately in teammates' node libraries, but the page's substantive sections (Custom Nodes Tab, Sharing Custom Nodes, Publishing Custom Nodes) only ever cover single code-based nodes generated by the Custom Node Builder from a natural-language description, not multi-step canvas workflows. No Gumloop page describes converting an existing built flow into a shareable, encapsulated block the way a Custom Node is shared.",
+        shortValue: "No: Subflows aren't org-shared; org-shared Custom Nodes are code, not flows",
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.gumloop.com/core-concepts/subflows',
+            label: 'Subflows - Gumloop docs',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://docs.gumloop.com/core-concepts/node_and_flow_library',
+            label: 'Node and Workflow Library - Gumloop docs',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://www.gumloop.com/blog/gumloop-custom-nodes',
+            label: 'Gumloop Blog: Gumloop Custom Nodes',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
     },
     aiCapabilities: {
       multiLlmSupport: {

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

@@ -333,6 +333,21 @@ export const langchainProfile: CompetitorProfile = {
           },
         ],
       },
+      customBlocks: {
+        value:
+          "No: LangChain/LangGraph has no drag-and-drop block toolbar at all, so there is no way to publish a deployed graph as a named, iconed block that other org members drop into their own separate graphs with auto-derived inputs and curated, renamed outputs. The closest adjacent capability is code-level: the RemoteGraph SDK class lets a developer add another team's deployed graph as a node in their own graph by writing code that points at its deployment URL and graph/assistant name.",
+        detail:
+          "RemoteGraph exposes the same programmatic interface as a locally compiled graph ('as if it were a local graph'), but the consuming developer must hand-write any state-schema-mapping wrapper code themselves, and there is no UI for picking/renaming which outputs to expose or for auto-deriving input fields from the source graph the way a visual builder does. LangChain's own docs describe RemoteGraph purely as an SDK for calling a deployment programmatically, not as a block placed in a shared, org-wide palette alongside built-in nodes.",
+        shortValue: 'No block toolbar exists; closest is code-level RemoteGraph SDK calls',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.langchain.com/langsmith/use-remote-graph',
+            label: 'How to interact with a deployment using RemoteGraph - Docs by LangChain',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
     },
     aiCapabilities: {
       multiLlmSupport: {

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

@@ -265,6 +265,26 @@ export const langflowProfile: CompetitorProfile = {
           },
         ],
       },
+      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: {

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

@@ -371,6 +371,31 @@ export const makeProfile: CompetitorProfile = {
           },
         ],
       },
+      customBlocks: {
+        value:
+          "No: Make has no feature to publish an existing scenario as an encapsulated, named block that appears in a shared module toolbar for other users across the organization to drop into their own separate scenarios. The closest capabilities are each narrower: 'Call a Scenario' (Subscenarios) can only invoke a scenario already created within the same team, is not exposed as a general block in a module picker, and Make's own docs don't describe it as hiding internal steps or always tracking a source's latest published version. 'Scenarios as AI Agent tools' lets a scenario's defined inputs/outputs be used as a callable tool, but only inside that specific AI Agent's own tool configuration, not as a general-purpose block any builder can add to any regular scenario. The Custom Apps SDK builds brand-new integration connectors that wrap third-party REST APIs; it has no mechanism to package an existing scenario itself as a block.",
+        detail:
+          "Per Make's Subscenarios help doc, you can 'only call a scenario created in your team,' scoping reuse to team boundaries rather than an org-wide block toolbar, with no documented internals-hiding or auto-latest-version guarantee. Per the Scenarios-for-AI-agents help doc, scenario-as-tool configuration happens inside AI Agents' own tab/module, not as a block available to all scenario builders. Per the Custom Apps Developer Hub, Custom Apps exist to integrate a third-party application that has no existing Make app, mapping REST endpoints and auth, not to publish an existing scenario as a reusable block.",
+        shortValue: 'No: no publish-scenario-as-org-wide-block feature',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://help.make.com/subscenarios',
+            label: 'Subscenarios - Make Help Center',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://help.make.com/scenarios-for-ai-agents',
+            label: 'Scenarios for AI agents - Make Help Center',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://developers.make.com/custom-apps-documentation',
+            label: 'Overview | Custom Apps Documentation | Make Developer Hub',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
     },
     aiCapabilities: {
       multiLlmSupport: {

apps/sim/lib/compare/data/competitors/microsoft-copilot.ts

@@ -375,6 +375,34 @@ export const microsoftCopilotProfile: CompetitorProfile = {
           },
         ],
       },
+      customBlocks: {
+        value:
+          "Partial: a published agent flow (with a 'When an agent calls the flow' trigger and a 'Respond to the agent' action) can be added by another maker as a tool, and a published Copilot Studio agent can be added by another maker as a connected-agent tool that always resolves to the source's latest published version — but discovery for both is a per-item share-and-pick model within one environment, not an admin-governed entry that automatically appears in a block toolbar for the whole org, and there is no publisher step to hand-pick and rename a curated subset of outputs the way Sim's Custom Blocks do.",
+        detail:
+          "Adding a flow as an agent-level tool lists qualifying, published flows in the 'Add tool > Flow' picker; Microsoft's docs don't specify how the tool's inputs are derived from the flow's trigger or confirm it always tracks the flow's latest published version. Connected agents are the better-documented half: a maker can turn on 'Let other agents connect to and use this one' on a published agent so any maker who owns it or has it shared with them can add it as a connected-agent tool in their own, separate agent, always using the latest published version after republish. Neither mechanism auto-populates a single, organization-wide block palette; each is discovered per-item through sharing/run permissions, and there's no dedicated step for the publisher to select and rename specific outputs to expose, unlike Sim's Custom Blocks.",
+        shortValue:
+          'Partial: published flows/agents become tools, but via per-item sharing, not an org-wide toolbar',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://learn.microsoft.com/en-us/microsoft-copilot-studio/flow-agent',
+            label:
+              'Add an agent flow as a tool to an agent - Microsoft Copilot Studio | Microsoft Learn',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://learn.microsoft.com/en-us/microsoft-copilot-studio/add-agent-copilot-studio-agent',
+            label:
+              'Connect to an existing Copilot Studio agent - Microsoft Copilot Studio | Microsoft Learn',
+            asOf: '2026-07-08',
+          },
+          {
+            url: 'https://learn.microsoft.com/en-us/microsoft-copilot-studio/authoring-add-other-agents',
+            label: 'Add other agents overview - Microsoft Copilot Studio | Microsoft Learn',
+            asOf: '2026-07-08',
+          },
+        ],
+      },
     },
     aiCapabilities: {
       multiLlmSupport: {