feat(comparison): add Sim vs Competitor comparison pages (#5383)

* feat(comparison): add Sim vs Competitor comparison pages

- New /comparison hub + /comparison/[provider] detail pages for Sim vs
  16 competitors (n8n, Zapier, Make, Gumloop, Workato, Retool,
  Pipedream, OpenAI AgentKit, Tines, StackAI, Power Automate, Vellum,
  Claude Cowork, Langflow, Flowise), each with ~60 sourced, dated facts
  across platform, AI capabilities, integrations, pricing, security,
  observability, and support
- Data layer at lib/compare/data (types, per-competitor profiles) is
  UI-free and independently auditable
- BreadcrumbList, ItemList, and FAQPage JSON-LD per page; sitemap picks
  up all pages automatically via ALL_COMPETITORS
- Two new fact categories (parallel execution, Agent2Agent protocol)
  researched and sourced against every competitor's own docs

* improvement(comparison): neutralize tone across competitor and Sim fact copy

- Remove promotional/superlative adjectives applied to competitors
  (Zapier "one of the largest catalogs", Workato "notably wide",
  Retool "seamless"/"trusted solution", OpenAI "cutting-edge",
  Flowise "deep"/"mature"/"most widely adopted", Make "robust")
- Reword the few places Sim's own accurate limitations read as
  unflattering rather than neutral fact (dynamic tool use, model
  fallback, durability, async execution, support channels, tracing)
  without changing the underlying facts
- Restore the "Yes:"/"No:" value prefix on two Sim facts where it was
  accidentally dropped during rewording, since FactValue depends on
  that prefix to render the check/X status icon

* fix(comparison): address review findings from Greptile and Cursor Bugbot

- Fix parseFactValue regex to require a word boundary after Yes/No, so
  values like "Not documented"/"Not publicly documented" no longer get
  misread as a boolean "No" and render as neutral text again (Cursor)
- Reword the self-hosting FAQ question to drop the false presupposition
  that the competitor doesn't self-host, which was wrong for n8n,
  Langflow, and Flowise (Greptile)
- Rename isLastRow -> isNotLastRow in comparison-table.tsx to match
  what the variable actually computes (Greptile)
- Move critters to devDependencies; it's a next build -time-only CSS
  inliner, not needed at runtime (Greptile)
- Sitemap lastModified for comparison pages now matches the max(Sim,
  competitor) verified-date logic each page's own JSON-LD dateModified
  already uses, so the two never disagree (Cursor)

* fix(comparison): fix doubled Yes prefix and missing period in hub FAQ

- Two hub FAQ answers prepended "Yes." to fact values that already
  start with "Yes:", producing "Yes. Yes: ..." in visible copy and
  FAQPage JSON-LD. Export and reuse ensurePeriod instead of a hardcoded
  prefix.
- The integrations-count FAQ answer ran two sentences together with no
  period before "Combined with...". Fixed with the same ensurePeriod
  helper.

* improvement(comparison): remove redundant Key differences at a glance section

The 5 facts it previewed (self-hosting, environment promotion,
human-in-the-loop, pricing model, data residency) are the exact same
rows shown again immediately below in the full comparison table, so
the section read as pure repetition for a human scrolling past it.

* fix(comparison): strip Yes/No prefix before lowercasing in summarizeFact

summarizeFact fed the raw fact value through lowercaseFirst even when
it started with "Yes: "/"No: ", producing broken mid-sentence FAQ text
like "n8n: yes: many providers via dedicated Chat Model nodes." Strip
the boolean prefix first, matching Greptile's suggested fix.

apps/sim/app/(landing)/comparison/[provider]/page.tsx

@@ -0,0 +1,317 @@
+import type { Metadata } from 'next'
+import { notFound } from 'next/navigation'
+import type { CompetitorProfile } from '@/lib/compare/data'
+import { simProfile } from '@/lib/compare/data'
+import { SITE_URL } from '@/lib/core/utils/urls'
+import { buildLandingMetadata } from '@/lib/landing/seo'
+import { COMPARISON_SECTIONS, getFactGroup } from '@/app/(landing)/comparison/comparison-sections'
+import { BrandIconTile, SimIconTile } from '@/app/(landing)/comparison/components/brand-icon-tile'
+import { ComparisonCards } from '@/app/(landing)/comparison/components/comparison-cards'
+import { ComparisonTable } from '@/app/(landing)/comparison/components/comparison-table'
+import {
+  ALL_COMPETITORS,
+  buildBottomLine,
+  buildComparisonFaqs,
+  getCompetitorBySlug,
+  getLatestVerifiedDate,
+  SIM_LATEST_VERIFIED,
+} from '@/app/(landing)/comparison/utils'
+import { BackLink } from '@/app/(landing)/components'
+import { Cta } from '@/app/(landing)/components/cta/cta'
+import { JsonLd } from '@/app/(landing)/components/json-ld'
+import { LandingFAQ } from '@/app/(landing)/components/landing-faq'
+
+const baseUrl = SITE_URL
+
+export const revalidate = 3600
+export const dynamicParams = false
+
+export async function generateStaticParams() {
+  return ALL_COMPETITORS.map((competitor) => ({ provider: competitor.id }))
+}
+
+/** Flattens a profile's facts into JSON-LD `additionalProperty` entries, in {@link COMPARISON_SECTIONS} order. */
+function factsToProperties(profile: CompetitorProfile) {
+  return COMPARISON_SECTIONS.flatMap((section) => {
+    const group = getFactGroup(profile, section.group)
+    return section.rows.map((row) => ({
+      '@type': 'PropertyValue',
+      name: row.label,
+      value: group[row.key]?.value ?? 'Unknown',
+    }))
+  })
+}
+
+export async function generateMetadata({
+  params,
+}: {
+  params: Promise<{ provider: string }>
+}): Promise<Metadata> {
+  const { provider: providerSlug } = await params
+  const competitor = getCompetitorBySlug(providerSlug)
+
+  if (!competitor) {
+    return {}
+  }
+
+  return buildLandingMetadata({
+    title: `Sim vs ${competitor.name}: AI Workspace Comparison`,
+    description: `Compare Sim, the open-source AI workspace, to ${competitor.name} on platform, AI, integrations, pricing, security, and support. Sourced and dated facts.`,
+    path: `/comparison/${competitor.id}`,
+    keywords: [
+      `Sim vs ${competitor.name}`,
+      `${competitor.name} alternative`,
+      `${competitor.name} vs Sim`,
+      `open source ${competitor.name} alternative`,
+      `${competitor.name} comparison`,
+      'AI agent workspace',
+      'AI workflow automation comparison',
+    ].join(', '),
+  })
+}
+
+export default async function ComparisonProviderPage({
+  params,
+}: {
+  params: Promise<{ provider: string }>
+}) {
+  const { provider: providerSlug } = await params
+  const competitor = getCompetitorBySlug(providerSlug)
+
+  if (!competitor) {
+    notFound()
+  }
+
+  const faqs = buildComparisonFaqs(competitor)
+  const verdict = buildBottomLine(competitor)
+  const CompetitorIcon = competitor.brand?.icon
+
+  const breadcrumbJsonLd = {
+    '@context': 'https://schema.org',
+    '@type': 'BreadcrumbList',
+    itemListElement: [
+      { '@type': 'ListItem', position: 1, name: 'Home', item: baseUrl },
+      { '@type': 'ListItem', position: 2, name: 'Comparison', item: `${baseUrl}/comparison` },
+      {
+        '@type': 'ListItem',
+        position: 3,
+        name: `Sim vs ${competitor.name}`,
+        item: `${baseUrl}/comparison/${competitor.id}`,
+      },
+    ],
+  }
+
+  const latestVerified = new Date(
+    Math.max(SIM_LATEST_VERIFIED.getTime(), getLatestVerifiedDate(competitor).getTime())
+  )
+
+  const productComparisonJsonLd = {
+    '@context': 'https://schema.org',
+    '@type': 'ItemList',
+    name: `Sim vs ${competitor.name}`,
+    description: `Feature and pricing comparison between Sim and ${competitor.name}.`,
+    url: `${baseUrl}/comparison/${competitor.id}`,
+    dateModified: latestVerified.toISOString().slice(0, 10),
+    numberOfItems: 2,
+    itemListElement: [
+      {
+        '@type': 'ListItem',
+        position: 1,
+        item: {
+          '@type': 'SoftwareApplication',
+          name: 'Sim',
+          applicationCategory: 'BusinessApplication',
+          url: SITE_URL,
+          description: simProfile.oneLiner,
+          additionalProperty: factsToProperties(simProfile),
+        },
+      },
+      {
+        '@type': 'ListItem',
+        position: 2,
+        item: {
+          '@type': 'SoftwareApplication',
+          name: competitor.name,
+          applicationCategory: 'BusinessApplication',
+          url: competitor.website,
+          description: competitor.oneLiner,
+          additionalProperty: factsToProperties(competitor),
+        },
+      },
+    ],
+  }
+
+  const faqJsonLd = {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faqs.map((faq) => ({
+      '@type': 'Question',
+      name: faq.question,
+      acceptedAnswer: {
+        '@type': 'Answer',
+        text: faq.answer,
+      },
+    })),
+  }
+
+  return (
+    <>
+      <JsonLd data={breadcrumbJsonLd} />
+      <JsonLd data={productComparisonJsonLd} />
+      <JsonLd data={faqJsonLd} />
+
+      <main id='main-content' className='bg-[var(--bg)]'>
+        <div className='mx-auto w-full max-w-[1446px] px-12 pt-[112px] max-sm:px-5 max-sm:pt-20 max-lg:px-8'>
+          <div className='mb-6'>
+            <BackLink href='/comparison' label='Back to comparisons' />
+          </div>
+
+          <div className='flex flex-col gap-4'>
+            <h1
+              id='comparison-heading'
+              className='text-balance text-[28px] text-[var(--text-primary)] leading-[100%] tracking-[-0.02em] lg:text-[40px]'
+            >
+              Sim vs {competitor.name}
+            </h1>
+            <p className='max-w-[720px] text-[var(--text-muted)] text-sm leading-[150%] tracking-[0.02em] lg:text-base'>
+              Sim is the open-source AI workspace where teams build, deploy, and manage AI agents
+              visually, conversationally, or with code. Here is how Sim compares to{' '}
+              {competitor.name} on platform architecture, AI capabilities, integrations, pricing,
+              security, and support. Every fact below is sourced and dated.
+            </p>
+            <p className='sr-only'>
+              Sim is an open-source AI workspace for building, deploying, and managing AI agents.
+              This page compares Sim to {competitor.name} across platform architecture, AI
+              capabilities, integrations, pricing, security and compliance, observability, and
+              support, using sourced, dated facts for buyers evaluating both platforms.
+            </p>
+          </div>
+        </div>
+
+        <div className='mt-8 h-px w-full bg-[var(--border)]' />
+
+        <div className='mx-auto w-full max-w-[1446px]'>
+          <div className='mx-12 border-[var(--border)] border-x max-sm:mx-5 max-lg:mx-8'>
+            <div className='grid grid-cols-1 sm:grid-cols-2'>
+              <section
+                aria-labelledby='what-is-sim-heading'
+                className='border-[var(--border)] border-r px-6 py-6 max-sm:border-r-0 max-sm:border-b'
+              >
+                <h2
+                  id='what-is-sim-heading'
+                  className='mb-2 flex items-center gap-2.5 text-[18px] text-[var(--text-primary)] leading-snug tracking-[-0.01em]'
+                >
+                  <SimIconTile className='size-9' />
+                  What is Sim?
+                </h2>
+                <p className='text-[var(--text-body)] text-small leading-[150%]'>
+                  {simProfile.oneLiner}
+                </p>
+              </section>
+              <section aria-labelledby='what-is-competitor-heading' className='px-6 py-6'>
+                <h2
+                  id='what-is-competitor-heading'
+                  className='mb-2 flex items-center gap-2.5 text-[18px] text-[var(--text-primary)] leading-snug tracking-[-0.01em]'
+                >
+                  {CompetitorIcon ? (
+                    <BrandIconTile
+                      icon={CompetitorIcon}
+                      selfFramed={competitor.brand?.selfFramed}
+                      className='size-9'
+                      iconClassName='size-5'
+                    />
+                  ) : null}
+                  What is {competitor.name}?
+                </h2>
+                <p className='text-[var(--text-body)] text-small leading-[150%]'>
+                  {competitor.oneLiner}
+                </p>
+              </section>
+            </div>
+
+            <div className='h-px w-full bg-[var(--border)]' />
+
+            <section aria-labelledby='comparison-table-heading' className='px-6 py-10'>
+              <h2
+                id='comparison-table-heading'
+                className='mb-4 text-[20px] text-[var(--text-primary)] leading-[100%] tracking-[-0.02em] lg:text-[24px]'
+              >
+                Sim vs {competitor.name}: feature-by-feature comparison
+              </h2>
+              <ComparisonTable sim={simProfile} competitor={competitor} />
+            </section>
+
+            <div className='h-px w-full bg-[var(--border)]' />
+
+            <div className='grid grid-cols-1 lg:grid-cols-2'>
+              <section
+                aria-labelledby='sim-standout-heading'
+                className='border-[var(--border)] border-r max-lg:border-r-0 max-lg:border-b'
+              >
+                <div className='px-6 pt-6 pb-2'>
+                  <h2
+                    id='sim-standout-heading'
+                    className='text-[18px] text-[var(--text-primary)] leading-snug tracking-[-0.01em]'
+                  >
+                    Sim standout features
+                  </h2>
+                </div>
+                <ComparisonCards items={simProfile.standoutFeatures} />
+              </section>
+              <section aria-labelledby='competitor-limitations-heading'>
+                <div className='px-6 pt-6 pb-2'>
+                  <h2
+                    id='competitor-limitations-heading'
+                    className='text-[18px] text-[var(--text-primary)] leading-snug tracking-[-0.01em]'
+                  >
+                    Documented {competitor.name} limitations
+                  </h2>
+                </div>
+                <ComparisonCards items={competitor.limitations} />
+              </section>
+            </div>
+
+            <div className='h-px w-full bg-[var(--border)]' />
+
+            <section aria-labelledby='bottom-line-heading' className='px-6 py-10'>
+              <h2
+                id='bottom-line-heading'
+                className='mb-4 text-[20px] text-[var(--text-primary)] leading-[100%] tracking-[-0.02em] lg:text-[24px]'
+              >
+                Bottom line
+              </h2>
+              <div className='flex flex-col gap-3'>
+                <p className='text-[var(--text-body)] text-small leading-[150%]'>
+                  {verdict.chooseSim}
+                </p>
+                <p className='text-[var(--text-body)] text-small leading-[150%]'>
+                  {verdict.chooseCompetitor}
+                </p>
+              </div>
+            </section>
+
+            <div className='h-px w-full bg-[var(--border)]' />
+
+            <section aria-labelledby='faq-heading' className='px-6 py-10'>
+              <h2
+                id='faq-heading'
+                className='mb-4 text-[20px] text-[var(--text-primary)] leading-[100%] tracking-[-0.02em] lg:text-[24px]'
+              >
+                Frequently asked questions
+              </h2>
+              <div>
+                <LandingFAQ faqs={faqs} />
+              </div>
+            </section>
+          </div>
+        </div>
+
+        <div className='-mt-px h-px w-full bg-[var(--border)]' />
+      </main>
+
+      <div className='py-16'>
+        <Cta />
+      </div>
+    </>
+  )
+}

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

@@ -0,0 +1,154 @@
+import type { ComparisonFacts, CompetitorProfile, Fact } from '@/lib/compare/data'
+
+/**
+ * The one place a {@link ComparisonFacts} group is read back out of a profile
+ * by group key. Every render-side consumer (the table, key-differences strip,
+ * JSON-LD builder) needs this same lookup; centralizing it here means there is
+ * exactly one cast to reason about instead of one per call site.
+ */
+export function getFactGroup<G extends keyof ComparisonFacts>(
+  profile: CompetitorProfile,
+  group: G
+): Record<string, Fact> {
+  return profile.facts[group] as Record<string, Fact>
+}
+
+/**
+ * One row in a comparison table section. Maps a human label to a fact key
+ * within a {@link ComparisonFacts} group. `key` is intentionally `string`
+ * (rather than a per-group `keyof` union) so a single array can hold rows
+ * for every group without TypeScript collapsing the distributed generic to
+ * `never`; correctness is enforced once, by construction, in
+ * {@link COMPARISON_SECTIONS} below, and the renderer reads through it.
+ */
+export interface ComparisonRowDef {
+  key: string
+  label: string
+}
+
+/** One section of the comparison table, mirroring a {@link ComparisonFacts} group. */
+export interface ComparisonSectionDef {
+  group: keyof ComparisonFacts
+  title: string
+  rows: ComparisonRowDef[]
+}
+
+/**
+ * Type-checks a section's rows against its own group's actual fact keys
+ * (via the per-call generic `G`), then widens to the plain `ComparisonRowDef`
+ * shape used by {@link COMPARISON_SECTIONS}. This is where row-key
+ * correctness is actually enforced. A typo here fails the build.
+ */
+function defineSection<G extends keyof ComparisonFacts>(section: {
+  group: G
+  title: string
+  rows: Array<{ key: keyof ComparisonFacts[G]; label: string }>
+}): ComparisonSectionDef {
+  return section as ComparisonSectionDef
+}
+
+/**
+ * Canonical section/row order for rendering a {@link ComparisonFacts} profile
+ * pair as a table. Single source of truth for row labels. Add a field here
+ * once and every comparison page picks it up.
+ */
+export const COMPARISON_SECTIONS: ComparisonSectionDef[] = [
+  defineSection({
+    group: 'platform',
+    title: 'Platform',
+    rows: [
+      { key: 'builderType', label: 'Builder type' },
+      { key: 'learningCurve', label: 'Learning curve' },
+      { key: 'selfHostOption', label: 'Self-hosting' },
+      { key: 'deploymentOptions', label: 'Deployment options' },
+      { key: 'templates', label: 'Templates' },
+      { key: 'license', label: 'License' },
+      { key: 'environmentPromotion', label: 'Environment promotion' },
+      { key: 'versionControlDepth', label: 'Version control' },
+      { key: 'realtimeCollaboration', label: 'Realtime collaboration' },
+      { key: 'nativeFileStorage', label: 'Native file storage' },
+    ],
+  }),
+  defineSection({
+    group: 'pricing',
+    title: 'Pricing',
+    rows: [
+      { key: 'pricingModel', label: 'Pricing model' },
+      { key: 'entryPaidPlan', label: 'Entry paid plan' },
+      { key: 'freeTier', label: 'Free tier' },
+      { key: 'byok', label: 'Bring your own key' },
+    ],
+  }),
+  defineSection({
+    group: 'security',
+    title: 'Security & compliance',
+    rows: [
+      { key: 'soc2', label: 'SOC 2' },
+      { key: 'dataResidency', label: 'Data residency' },
+      { key: 'rbac', label: 'Role-based access control' },
+      { key: 'auditLogging', label: 'Audit logging' },
+      { key: 'additionalCompliance', label: 'Additional compliance' },
+      { key: 'modelAndToolGovernance', label: 'Model & tool governance' },
+      { key: 'credentialGovernance', label: 'Credential governance' },
+      { key: 'sso', label: 'Single sign-on (SSO)' },
+      { key: 'piiRedaction', label: 'PII redaction' },
+      { key: 'dataRetention', label: 'Custom data retention' },
+      { key: 'whiteLabeling', label: 'White-labeling' },
+    ],
+  }),
+  defineSection({
+    group: 'aiCapabilities',
+    title: 'AI capabilities',
+    rows: [
+      { key: 'multiLlmSupport', label: 'Multi-LLM support' },
+      { key: 'agentReasoningBlocks', label: 'Agent reasoning blocks' },
+      { key: 'naturalLanguageBuilding', label: 'Natural-language building' },
+      { key: 'knowledgeBaseRag', label: 'Knowledge base / RAG' },
+      { key: 'mcpSupport', label: 'MCP support' },
+      { key: 'evaluationGuardrails', label: 'Evaluation & guardrails' },
+      { key: 'humanInTheLoop', label: 'Human-in-the-loop' },
+      { key: 'generativeMedia', label: 'Generative media' },
+      { key: 'dynamicToolUse', label: 'Dynamic tool use' },
+      { key: 'modelFallback', label: 'Automatic model fallback' },
+      { key: 'agentSkills', label: 'Agent skills' },
+      { key: 'nativeChatDeployment', label: 'Native chat deployment' },
+      { key: 'parallelExecution', label: 'Parallel execution' },
+      { key: 'a2aProtocol', label: 'Agent2Agent (A2A) protocol' },
+    ],
+  }),
+  defineSection({
+    group: 'integrations',
+    title: 'Integrations',
+    rows: [
+      { key: 'integrationCount', label: 'Integrations' },
+      { key: 'triggerTypes', label: 'Trigger types' },
+      { key: 'customCodeSteps', label: 'Custom code steps' },
+      { key: 'apiPublishing', label: 'API publishing' },
+      { key: 'extensibilitySdk', label: 'SDKs & extensibility' },
+      { key: 'mcpPublishing', label: 'Publish as MCP server' },
+    ],
+  }),
+  defineSection({
+    group: 'observability',
+    title: 'Observability & durability',
+    rows: [
+      { key: 'tracingDepth', label: 'Tracing & observability' },
+      { key: 'durabilityModel', label: 'Durability & retries' },
+      { key: 'failureAlerting', label: 'Failure alerting' },
+      { key: 'dataDrains', label: 'Data drains' },
+      { key: 'asyncExecution', label: 'Async execution' },
+      { key: 'executionLimits', label: 'Execution limits' },
+      { key: 'partialFailureHandling', label: 'Partial-failure handling' },
+    ],
+  }),
+  defineSection({
+    group: 'support',
+    title: 'Support',
+    rows: [
+      { key: 'supportChannels', label: 'Support channels' },
+      { key: 'sla', label: 'SLA' },
+      { key: 'community', label: 'Community' },
+      { key: 'academy', label: 'Academy / training' },
+    ],
+  }),
+]

apps/sim/app/(landing)/comparison/components/brand-icon-tile/brand-icon-tile.tsx

@@ -0,0 +1,83 @@
+import type { ComponentType, SVGProps } from 'react'
+import { cn } from '@sim/emcn'
+import type { CompetitorBrand } from '@/lib/compare/data'
+import { SimWordmark } from '@/app/(landing)/components/navbar/components/sim-wordmark'
+
+export interface BrandIconTileProps {
+  icon: ComponentType<SVGProps<SVGSVGElement>>
+  /**
+   * Whether `icon` already renders a full, self-contained brand-colored
+   * square (e.g. a fetched app-store-style logo) rather than a bare
+   * transparent glyph. See {@link CompetitorBrand.selfFramed}.
+   */
+  selfFramed?: boolean
+  /** Outer tile size, e.g. `size-8`. Defaults to the integrations-page card size. */
+  className?: string
+  /** Icon glyph size inside the tile, e.g. `size-4`. Ignored when `selfFramed`. */
+  iconClassName?: string
+}
+
+/**
+ * A rounded, bordered icon tile matching the platform's app-icon chrome
+ * conventions (border radius, border token, background), so competitor brand
+ * logos read as the same first-class "app icon" chrome as the rest of the
+ * product, instead of a bare, unframed SVG floating in the layout.
+ *
+ * A self-framed logo (already a complete brand-colored square) fills the
+ * tile edge-to-edge, clipped to the same rounded corners. Otherwise the icon
+ * is a small transparent glyph centered on a plain bordered background.
+ */
+export function BrandIconTile({
+  icon: Icon,
+  selfFramed = false,
+  className = 'size-8',
+  iconClassName = 'size-4',
+}: BrandIconTileProps) {
+  if (selfFramed) {
+    return (
+      <div
+        className={cn(
+          'shrink-0 overflow-hidden rounded-xl border border-[var(--border-1)]',
+          className
+        )}
+      >
+        <Icon className='size-full' aria-hidden='true' />
+      </div>
+    )
+  }
+  return (
+    <div
+      className={cn(
+        'flex shrink-0 items-center justify-center rounded-xl border border-[var(--border-1)] bg-[var(--bg)]',
+        className
+      )}
+    >
+      <Icon className={iconClassName} aria-hidden='true' />
+    </div>
+  )
+}
+
+export interface SimIconTileProps {
+  /** Outer tile size, e.g. `size-8`. Defaults to the integrations-page card size. */
+  className?: string
+}
+
+/**
+ * The same rounded, bordered tile as {@link BrandIconTile}, but for Sim's own
+ * wordmark. So "Sim" gets the identical icon-chip treatment as every
+ * competitor it's compared against, instead of appearing as bare text.
+ */
+export function SimIconTile({ className = 'size-8' }: SimIconTileProps) {
+  return (
+    <div
+      className={cn(
+        'flex shrink-0 items-center justify-center rounded-xl border border-[var(--border-1)] bg-[var(--bg)]',
+        className
+      )}
+    >
+      <span className='inline-flex scale-[0.6]'>
+        <SimWordmark />
+      </span>
+    </div>
+  )
+}

apps/sim/app/(landing)/comparison/components/brand-icon-tile/index.ts

@@ -0,0 +1,2 @@
+export type { BrandIconTileProps, SimIconTileProps } from './brand-icon-tile'
+export { BrandIconTile, SimIconTile } from './brand-icon-tile'

apps/sim/app/(landing)/comparison/components/comparison-cards/comparison-cards.tsx

@@ -0,0 +1,47 @@
+import type { FactSource } from '@/lib/compare/data'
+import { SourceLink } from '@/app/(landing)/comparison/components/source-info'
+
+interface ComparisonCardItem {
+  title: string
+  description: string
+  shortDescription?: string
+  source: FactSource
+}
+
+export interface ComparisonCardsProps {
+  items: ComparisonCardItem[]
+}
+
+/**
+ * A vertically stacked list of atomic, independently quotable fact cards,
+ * each self-contained title + a one-line `shortDescription` (falling back to
+ * `description` if a short version hasn't been authored yet). Used for both
+ * a competitor's standout features and its documented limitations.
+ *
+ * The full `description` is always present as `sr-only` text. Server
+ * rendered regardless of hover/JS state. So an LLM or crawler reading the
+ * page still gets the complete claim even though a human sees only the
+ * one-line summary. Hovering the title itself (`SourceLink`) shows a short
+ * "Source: X" tooltip and clicking it opens the source, rather than a
+ * separate info-icon affordance next to every card.
+ */
+export function ComparisonCards({ items }: ComparisonCardsProps) {
+  return (
+    <div className='flex flex-col'>
+      {items.map((item, index) => (
+        <div
+          key={item.title}
+          className={index > 0 ? 'border-[var(--border)] border-t px-6 py-4' : 'px-6 py-4'}
+        >
+          <h3 className='mb-1 text-[var(--text-primary)] text-base leading-snug tracking-[-0.01em]'>
+            <SourceLink source={item.source}>{item.title}</SourceLink>
+          </h3>
+          <p className='text-[var(--text-body)] text-small leading-[150%]'>
+            {item.shortDescription ?? item.description}
+          </p>
+          {item.shortDescription ? <span className='sr-only'>{item.description}</span> : null}
+        </div>
+      ))}
+    </div>
+  )
+}

apps/sim/app/(landing)/comparison/components/comparison-cards/index.ts

@@ -0,0 +1,2 @@
+export type { ComparisonCardsProps } from './comparison-cards'
+export { ComparisonCards } from './comparison-cards'

apps/sim/app/(landing)/comparison/components/comparison-table/comparison-table.tsx

@@ -0,0 +1,151 @@
+import type { ReactNode } from 'react'
+import { cn } from '@sim/emcn'
+import type { CompetitorProfile } from '@/lib/compare/data'
+import { COMPARISON_SECTIONS, getFactGroup } from '@/app/(landing)/comparison/comparison-sections'
+import { BrandIconTile, SimIconTile } from '@/app/(landing)/comparison/components/brand-icon-tile'
+import { FactValue } from '@/app/(landing)/comparison/components/fact-value'
+
+export interface ComparisonTableProps {
+  sim: CompetitorProfile
+  competitor: CompetitorProfile
+}
+
+function ColumnHeader({
+  name,
+  iconTile,
+  isSim,
+}: {
+  name: string
+  iconTile: ReactNode
+  isSim: boolean
+}) {
+  return (
+    <div
+      className={cn(
+        'flex flex-col items-center gap-2 border-[var(--border-1)] border-b px-3 py-4 text-center',
+        isSim ? 'bg-[var(--surface-2)]' : 'bg-[var(--surface-1)]'
+      )}
+    >
+      {iconTile}
+      <span className='font-medium text-[var(--text-primary)] text-base'>{name}</span>
+    </div>
+  )
+}
+
+/**
+ * Two-column "Sim vs {Competitor}" fact table, styled after the billing
+ * upgrade-page comparison table (same border/hairline rhythm and section
+ * headers) but data-driven off {@link CompetitorProfile.facts} instead of the
+ * fixed 4-tier plan schema. Data cells share one neutral surface for both
+ * columns. The Sim column is called out only in the header row (a bottom
+ * accent border), so the table reads as one clean grid rather than a
+ * checkerboard. Pure server component: every value is plain server-rendered
+ * text so crawlers and AI answer engines read the full comparison without
+ * any client-side hydration.
+ */
+export function ComparisonTable({ sim, competitor }: ComparisonTableProps) {
+  return (
+    <div className='w-full overflow-x-auto rounded-xl border border-[var(--border-1)]'>
+      <div
+        role='table'
+        aria-label={`Sim vs ${competitor.name} feature comparison`}
+        className='grid min-w-[560px] grid-cols-[1.2fr_1fr_1fr]'
+      >
+        <div className='contents' role='row'>
+          <div
+            role='columnheader'
+            className='flex flex-col justify-center border-[var(--border)] border-r border-b bg-[var(--surface-1)] px-4 py-4'
+          >
+            <span className='font-medium text-[var(--text-primary)] text-base'>Compare</span>
+            <span className='text-[var(--text-muted)] text-small'>
+              {sim.name} vs {competitor.name}
+            </span>
+          </div>
+          <ColumnHeader name={sim.name} iconTile={<SimIconTile className='size-9' />} isSim />
+          <ColumnHeader
+            name={competitor.name}
+            iconTile={
+              competitor.brand?.icon ? (
+                <BrandIconTile
+                  icon={competitor.brand.icon}
+                  selfFramed={competitor.brand.selfFramed}
+                  className='size-9'
+                  iconClassName='size-5'
+                />
+              ) : null
+            }
+            isSim={false}
+          />
+        </div>
+
+        {COMPARISON_SECTIONS.map((section, sectionIdx) => {
+          const simGroupFacts = getFactGroup(sim, section.group)
+          const competitorGroupFacts = getFactGroup(competitor, section.group)
+
+          return (
+            <div key={section.title} className='contents'>
+              <div className='contents' role='row'>
+                <div
+                  role='columnheader'
+                  className={cn(
+                    'border-[var(--border)] border-r bg-[var(--surface-1)] px-4 py-2',
+                    sectionIdx > 0 && 'border-[var(--border-1)] border-t'
+                  )}
+                >
+                  <span className='font-medium text-[var(--text-primary)] text-small'>
+                    {section.title}
+                  </span>
+                </div>
+                <div
+                  role='presentation'
+                  className={cn(
+                    'col-span-2 bg-[var(--surface-1)]',
+                    sectionIdx > 0 && 'border-[var(--border-1)] border-t'
+                  )}
+                />
+              </div>
+
+              {section.rows.map((row, rowIdx) => {
+                const simFact = simGroupFacts[row.key]
+                const competitorFact = competitorGroupFacts[row.key]
+                const isNotLastRow = rowIdx < section.rows.length - 1
+
+                return (
+                  <div key={row.key} className='contents' role='row'>
+                    <div
+                      role='rowheader'
+                      className={cn(
+                        'flex items-center border-[var(--border)] border-r bg-[var(--surface-1)] px-4 py-2.5',
+                        isNotLastRow && 'border-[var(--border-1)] border-b'
+                      )}
+                    >
+                      <span className='text-[var(--text-body)] text-small'>{row.label}</span>
+                    </div>
+                    <div
+                      role='cell'
+                      className={cn(
+                        'flex items-center border-[var(--border)] border-r bg-[var(--surface-2)] px-3 py-2.5',
+                        isNotLastRow && 'border-[var(--border-1)] border-b'
+                      )}
+                    >
+                      <FactValue fact={simFact} />
+                    </div>
+                    <div
+                      role='cell'
+                      className={cn(
+                        'flex items-center bg-[var(--surface-2)] px-3 py-2.5',
+                        isNotLastRow && 'border-[var(--border-1)] border-b'
+                      )}
+                    >
+                      <FactValue fact={competitorFact} />
+                    </div>
+                  </div>
+                )
+              })}
+            </div>
+          )
+        })}
+      </div>
+    </div>
+  )
+}

apps/sim/app/(landing)/comparison/components/comparison-table/index.ts

@@ -0,0 +1,2 @@
+export type { ComparisonTableProps } from './comparison-table'
+export { ComparisonTable } from './comparison-table'

apps/sim/app/(landing)/comparison/components/fact-value/fact-value.tsx

@@ -0,0 +1,67 @@
+import { Check, X } from '@sim/emcn/icons'
+import type { Fact } from '@/lib/compare/data'
+import { SourceLink } from '@/app/(landing)/comparison/components/source-info'
+import { parseFactValue } from '@/app/(landing)/comparison/fact-status'
+
+export interface FactValueProps {
+  fact: Fact
+}
+
+/**
+ * Renders one {@link Fact} for a glancing reader while keeping the full
+ * granular fact server-rendered for crawlers and AI answer engines.
+ *
+ * - A true "Yes"/"No" fact renders as an icon alone (a monochrome check or
+ *   muted cross, no colored pass/fail styling), no visible text, since the
+ *   label column and surrounding context already say what's being asked.
+ * - Any other fact shows its `shortValue` (a compact, pre-authored
+ *   restatement of `value`), never the full sentence.
+ * - `Tooltip` here is a cursor-following mini-bubble meant for a short
+ *   one-line label (see its own docs/usages: "Refresh", "last updated: X")
+ *  . It is deliberately NOT used to hold paragraph-length detail text, only
+ *   the compact source citation, which is exactly what it's designed for.
+ * - When a source exists, the visible glance (icon or `shortValue` text)
+ *   IS the hover/click target for that source, via `SourceLink`, rather
+ *   than a separate info-icon next to every value. One affordance per
+ *   fact keeps a 58-row table from reading as icon-cluttered.
+ * - A `sr-only` span always carries the complete value, detail, and source
+ *   in the initial server-rendered HTML, independent of hover/JS state, so
+ *   an LLM or crawler reading the page gets full granularity even though a
+ *   human sees only the compact glance.
+ */
+export function FactValue({ fact }: FactValueProps) {
+  const { status, text } = parseFactValue(fact.value)
+  const isBoolean = status === 'yes' || status === 'no'
+  const primarySource = fact.sources[0]
+
+  const fullText = [fact.value, fact.detail].filter(Boolean).join('. ')
+
+  const glance = isBoolean ? (
+    status === 'yes' ? (
+      <Check className='size-[14px] shrink-0 text-[var(--text-primary)]' aria-hidden='true' />
+    ) : (
+      <X className='size-[14px] shrink-0 text-[var(--text-muted)]' aria-hidden='true' />
+    )
+  ) : null
+
+  // A pure yes/no fact renders as an icon only. The "why" lives in the
+  // source link and the sr-only text, not cluttering the glance view.
+  const shortText = isBoolean ? null : (fact.shortValue ?? text)
+
+  const valueNode = glance ?? (
+    <span className='truncate text-[var(--text-body)] text-small'>{shortText}</span>
+  )
+
+  return (
+    <div className='flex min-w-0 items-center gap-1.5'>
+      {primarySource ? (
+        <SourceLink source={primarySource} className={glance ? 'shrink-0' : 'min-w-0 truncate'}>
+          {valueNode}
+        </SourceLink>
+      ) : (
+        valueNode
+      )}
+      <span className='sr-only'>{fullText}</span>
+    </div>
+  )
+}

apps/sim/app/(landing)/comparison/components/fact-value/index.ts

@@ -0,0 +1,2 @@
+export type { FactValueProps } from './fact-value'
+export { FactValue } from './fact-value'

apps/sim/app/(landing)/comparison/components/source-info/index.ts

@@ -0,0 +1,2 @@
+export type { SourceLinkProps } from './source-info'
+export { SourceLink } from './source-info'

apps/sim/app/(landing)/comparison/components/source-info/source-info.tsx

@@ -0,0 +1,40 @@
+'use client'
+
+import type { ReactNode } from 'react'
+import { Tooltip } from '@sim/emcn'
+import type { FactSource } from '@/lib/compare/data'
+
+export interface SourceLinkProps {
+  source: FactSource
+  children: ReactNode
+  /** Additional classes for the trigger element (the visible value/title). */
+  className?: string
+}
+
+/**
+ * Wraps a fact's visible value (or a card's title) so hovering it directly
+ * shows a one-line "Source: X" tooltip, and clicking it opens the source,
+ * rather than a separate info-icon affordance next to every value. One
+ * hover/click target per fact instead of two keeps the dense comparison
+ * table and card lists from reading as icon-cluttered. Every {@link FactSource}
+ * carries a real, publicly reachable URL (enforced by the type), so this
+ * always renders as a link.
+ */
+export function SourceLink({ source, children, className }: SourceLinkProps) {
+  return (
+    <Tooltip.Root>
+      <Tooltip.Trigger asChild>
+        <a
+          href={source.url}
+          target='_blank'
+          rel='noopener noreferrer'
+          aria-label={`${source.label} (opens source)`}
+          className={className}
+        >
+          {children}
+        </a>
+      </Tooltip.Trigger>
+      <Tooltip.Content>Source: {source.label}</Tooltip.Content>
+    </Tooltip.Root>
+  )
+}

apps/sim/app/(landing)/comparison/fact-status.ts

@@ -0,0 +1,34 @@
+/** Status implied by a fact's leading "Yes"/"No" token, if any. */
+export type FactStatus = 'yes' | 'no' | 'neutral'
+
+export interface ParsedFact {
+  status: FactStatus
+  /** The value with any leading "Yes:"/"No:" token stripped, ready to render next to a status icon. */
+  text: string
+}
+
+// The negative lookahead (?![a-zA-Z]) requires the "Yes"/"No" token to end at a word
+// boundary, so values like "Not documented" or "Not publicly documented" (which start
+// with the letters "No" but aren't the boolean token) fall through to 'neutral' instead
+// of being misread as a "No" status.
+const STATUS_PREFIX = /^(Yes|No)(?![a-zA-Z])(?::\s*)?(.*)$/s
+
+/**
+ * Splits a {@link Fact.value} string into a status (for a compact icon) and
+ * the remaining descriptive text. Every fact in `apps/sim/lib/compare/data`
+ * that represents a yes/no capability is written as `"Yes: ..."` / `"No:
+ * ..."`. This is the single place that convention is parsed, so the
+ * comparison table and the key-differences strip render it identically.
+ */
+export function parseFactValue(value: string): ParsedFact {
+  const match = value.match(STATUS_PREFIX)
+  if (!match) {
+    return { status: 'neutral', text: value }
+  }
+  const [, token, rest] = match
+  const trimmedRest = rest.trim()
+  return {
+    status: token === 'Yes' ? 'yes' : 'no',
+    text: trimmedRest.length > 0 ? trimmedRest : token,
+  }
+}

apps/sim/app/(landing)/comparison/not-found.tsx

@@ -0,0 +1,26 @@
+import { ChipLink } from '@sim/emcn'
+import type { Metadata } from 'next'
+
+export const metadata: Metadata = {
+  title: 'Page Not Found',
+  robots: { index: false, follow: true },
+}
+
+export default function ComparisonNotFound() {
+  return (
+    <main
+      id='main-content'
+      className='mx-auto flex min-h-[60vh] w-full max-w-[1446px] flex-col items-center justify-center gap-3 px-12 py-24 text-center max-sm:px-5 max-lg:px-8'
+    >
+      <h1 className='text-balance text-[40px] text-[var(--text-primary)] leading-[110%] tracking-[-0.02em]'>
+        Comparison not found
+      </h1>
+      <p className='text-[var(--text-muted)] text-lg'>
+        The comparison you&apos;re looking for doesn&apos;t exist or has been moved.
+      </p>
+      <ChipLink variant='primary' href='/comparison' className='mt-3'>
+        Browse comparisons
+      </ChipLink>
+    </main>
+  )
+}

apps/sim/app/(landing)/comparison/page.tsx

@@ -0,0 +1,194 @@
+import type { Metadata } from 'next'
+import Link from 'next/link'
+import { simProfile } from '@/lib/compare/data'
+import { SITE_URL } from '@/lib/core/utils/urls'
+import { buildLandingMetadata } from '@/lib/landing/seo'
+import { BrandIconTile } from '@/app/(landing)/comparison/components/brand-icon-tile'
+import { ALL_COMPETITORS, ensurePeriod, lowercaseFirst } from '@/app/(landing)/comparison/utils'
+import { ChevronArrow } from '@/app/(landing)/components/chevron-arrow'
+import { JsonLd } from '@/app/(landing)/components/json-ld'
+import { LandingFAQ } from '@/app/(landing)/components/landing-faq'
+
+const baseUrl = SITE_URL
+
+export const revalidate = 3600
+
+const faqItems = [
+  {
+    question: 'How does Sim compare to workflow automation and AI agent platforms?',
+    answer:
+      'Sim is an open-source AI workspace where teams build, deploy, and manage AI agents visually, conversationally, or with code. Compared to workflow automation tools like n8n, Zapier, and Make, Sim treats AI agents as first-class building blocks rather than an add-on to data routing, and ships a native knowledge base, MCP support, and an in-editor AI Copilot. Compared to enterprise AI builders like Gumloop, Workato, StackAI, and Vellum, Sim is fully open source (Apache 2.0) and self-hostable, so teams can run it on their own infrastructure.',
+  },
+  {
+    question: 'Is Sim open source?',
+    answer:
+      'Yes. Sim is released under the Apache License 2.0 and can be self-hosted via Docker or Kubernetes, or used as a managed cloud-hosted service.',
+  },
+  {
+    question: 'Which AI agent platform should I choose?',
+    answer:
+      "The right platform depends on what you're optimizing for: licensing and data control (Sim, n8n self-hosted), integration breadth (Zapier, Pipedream), enterprise governance (Workato, Tines), or AI-native agent building specifically (Sim, Gumloop, StackAI). Each comparison page on this site lays out sourced, dated facts across platform, AI capabilities, integrations, pricing, security, and support so you can weigh the tradeoffs for your team.",
+  },
+  {
+    question: 'Is Sim free to use?',
+    answer: `${ensurePeriod(simProfile.facts.pricing.freeTier.value)} Sim is also free to self-host under the Apache 2.0 license with no seat or usage limits beyond your own infrastructure.`,
+  },
+  {
+    question: 'Does Sim support MCP (Model Context Protocol)?',
+    answer: `${ensurePeriod(simProfile.facts.aiCapabilities.mcpSupport.value)} Sim can also publish any deployed workflow as its own MCP server, so it works as both an MCP client and an MCP server.`,
+  },
+  {
+    question: 'How many integrations does Sim support?',
+    answer: `Sim ships ${ensurePeriod(lowercaseFirst(simProfile.facts.integrations.integrationCount.value))} Combined with native MCP client support, teams can extend Sim to any service with a public API, not just the built-in catalog.`,
+  },
+]
+
+export const metadata: Metadata = buildLandingMetadata({
+  title: 'Sim Comparisons: AI Agent & Workflow Platforms',
+  description:
+    'Compare Sim, the open-source AI workspace, to n8n, Zapier, Make, and other workflow automation and AI agent platforms. Sourced, dated, fact-checked.',
+  path: '/comparison',
+  keywords: [
+    'Sim comparison',
+    'Sim vs n8n',
+    'Sim vs Zapier',
+    'Sim alternative',
+    'AI agent platform comparison',
+    'workflow automation comparison',
+    'open source AI workspace',
+  ].join(', '),
+})
+
+export default function ComparisonHubPage() {
+  const breadcrumbJsonLd = {
+    '@context': 'https://schema.org',
+    '@type': 'BreadcrumbList',
+    itemListElement: [
+      { '@type': 'ListItem', position: 1, name: 'Home', item: baseUrl },
+      { '@type': 'ListItem', position: 2, name: 'Comparison', item: `${baseUrl}/comparison` },
+    ],
+  }
+
+  const itemListJsonLd = {
+    '@context': 'https://schema.org',
+    '@type': 'ItemList',
+    name: 'Sim Comparisons',
+    description: 'Directory of Sim comparison pages against AI agent and workflow platforms.',
+    url: `${baseUrl}/comparison`,
+    numberOfItems: ALL_COMPETITORS.length,
+    itemListElement: ALL_COMPETITORS.map((competitor, index) => ({
+      '@type': 'ListItem',
+      position: index + 1,
+      url: `${baseUrl}/comparison/${competitor.id}`,
+      name: `Sim vs ${competitor.name}`,
+    })),
+  }
+
+  const faqJsonLd = {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faqItems.map((item) => ({
+      '@type': 'Question',
+      name: item.question,
+      acceptedAnswer: { '@type': 'Answer', text: item.answer },
+    })),
+  }
+
+  return (
+    <>
+      <JsonLd data={breadcrumbJsonLd} />
+      <JsonLd data={itemListJsonLd} />
+      <JsonLd data={faqJsonLd} />
+
+      <main id='main-content' className='bg-[var(--bg)]'>
+        <div className='mx-auto w-full max-w-[1446px] px-12 pt-[112px] max-sm:px-5 max-sm:pt-20 max-lg:px-8'>
+          {/* Invisible spacer matching the detail page's BackLink block height/margin, so the divider below lands at the same Y on both pages. */}
+          <div className='mb-6 h-6' aria-hidden='true' />
+
+          <div className='flex flex-col gap-4'>
+            <h1
+              id='comparison-hub-heading'
+              className='text-balance text-[28px] text-[var(--text-primary)] leading-[100%] tracking-[-0.02em] lg:text-[40px]'
+            >
+              Sim comparisons
+            </h1>
+            <p className='max-w-[720px] text-[var(--text-muted)] text-sm leading-[150%] tracking-[0.02em] lg:text-base'>
+              Sim is the open-source AI workspace where teams build, deploy, and manage AI agents.
+              See how Sim compares to workflow automation platforms and AI agent builders on
+              platform architecture, AI capabilities, integrations, pricing, security, and support.
+            </p>
+            <p className='sr-only'>
+              This directory lists every Sim vs. competitor comparison page, covering workflow
+              automation platforms (n8n, Zapier, Make, Pipedream), enterprise AI builders (Gumloop,
+              Workato, Retool, Tines, StackAI, Power Automate, Vellum), and AI agent products
+              (OpenAI AgentKit, Claude Cowork). Each page gives sourced, dated facts across
+              platform, AI capabilities, integrations, pricing, security, and support.
+            </p>
+          </div>
+        </div>
+
+        <div className='mt-8 h-px w-full bg-[var(--border)]' />
+
+        <div className='mx-auto w-full max-w-[1446px] px-12 max-sm:px-5 max-lg:px-8'>
+          <div className='border-[var(--border)] border-x'>
+            <section aria-labelledby='all-comparisons-heading' className='pt-10'>
+              <h2
+                id='all-comparisons-heading'
+                className='mb-4 px-6 text-[20px] text-[var(--text-primary)] leading-[100%] tracking-[-0.02em] lg:text-[24px]'
+              >
+                All comparisons
+              </h2>
+              <div>
+                {ALL_COMPETITORS.map((competitor) => {
+                  const Icon = competitor.brand?.icon
+                  return (
+                    <div key={competitor.id}>
+                      <Link
+                        href={`/comparison/${competitor.id}`}
+                        className='group/link flex items-center gap-4 px-6 py-4 transition-colors hover-hover:bg-[var(--surface-hover)]'
+                        aria-label={`Sim vs ${competitor.name} comparison`}
+                      >
+                        {Icon ? (
+                          <BrandIconTile
+                            icon={Icon}
+                            selfFramed={competitor.brand?.selfFramed}
+                            className='size-8 shrink-0'
+                            iconClassName='size-4'
+                          />
+                        ) : null}
+                        <div className='flex min-w-0 flex-1 flex-col gap-0.5'>
+                          <h3 className='text-[var(--text-primary)] text-sm leading-snug tracking-[-0.02em]'>
+                            Sim vs {competitor.name}
+                          </h3>
+                          <p className='hidden text-[var(--text-muted)] text-caption leading-[150%] sm:line-clamp-1'>
+                            {competitor.oneLiner}
+                          </p>
+                        </div>
+                        <ChevronArrow />
+                      </Link>
+                      <div className='h-px w-full bg-[var(--border)]' />
+                    </div>
+                  )
+                })}
+              </div>
+            </section>
+
+            <section aria-labelledby='faq-heading' className='px-6 py-10'>
+              <h2
+                id='faq-heading'
+                className='mb-4 text-[20px] text-[var(--text-primary)] leading-[100%] tracking-[-0.02em] lg:text-[24px]'
+              >
+                Frequently asked questions
+              </h2>
+              <div>
+                <LandingFAQ faqs={faqItems} />
+              </div>
+            </section>
+          </div>
+        </div>
+
+        <div className='-mt-px h-px w-full bg-[var(--border)]' />
+      </main>
+    </>
+  )
+}

apps/sim/app/(landing)/comparison/utils.ts

@@ -0,0 +1,214 @@
+import {
+  type CompetitorProfile,
+  claudeCoworkProfile,
+  flowiseProfile,
+  gumloopProfile,
+  langflowProfile,
+  makeProfile,
+  n8nProfile,
+  openaiAgentkitProfile,
+  pipedreamProfile,
+  powerAutomateProfile,
+  retoolProfile,
+  simProfile,
+  stackaiProfile,
+  tinesProfile,
+  vellumProfile,
+  workatoProfile,
+  zapierProfile,
+} from '@/lib/compare/data'
+
+export interface ComparisonFaq {
+  question: string
+  answer: string
+}
+
+/** Every competitor Sim is compared against, in display/build order. */
+export const ALL_COMPETITORS: CompetitorProfile[] = [
+  n8nProfile,
+  zapierProfile,
+  makeProfile,
+  gumloopProfile,
+  workatoProfile,
+  retoolProfile,
+  pipedreamProfile,
+  openaiAgentkitProfile,
+  tinesProfile,
+  stackaiProfile,
+  powerAutomateProfile,
+  vellumProfile,
+  claudeCoworkProfile,
+  langflowProfile,
+  flowiseProfile,
+]
+
+const COMPETITOR_BY_SLUG = new Map(ALL_COMPETITORS.map((c) => [c.id, c]))
+
+export function getCompetitorBySlug(slug: string): CompetitorProfile | null {
+  return COMPETITOR_BY_SLUG.get(slug) ?? null
+}
+
+/**
+ * The most recent `asOf` date across every fact source in a profile. Used as
+ * the sitemap `lastModified` for that competitor's comparison page, so the
+ * sitemap reflects when the underlying facts were actually last verified.
+ */
+export function getLatestVerifiedDate(profile: CompetitorProfile): Date {
+  let latest = 0
+  for (const group of Object.values(profile.facts)) {
+    for (const fact of Object.values(group as Record<string, { sources: { asOf: string }[] }>)) {
+      for (const source of fact.sources) {
+        const time = new Date(source.asOf).getTime()
+        if (!Number.isNaN(time) && time > latest) {
+          latest = time
+        }
+      }
+    }
+  }
+  return latest > 0 ? new Date(latest) : new Date()
+}
+
+/** Sim's own latest-verified date, identical across every competitor page, computed once. */
+export const SIM_LATEST_VERIFIED = getLatestVerifiedDate(simProfile)
+
+/**
+ * A short, atomic "who should pick which platform" verdict. The single
+ * block most comparison-page readers (and AI answer engines asked "should I
+ * use Sim or {competitor}") are actually looking for. Both sentences name
+ * both products explicitly and stay factual, drawing on the competitor's own
+ * documented standout feature rather than a generic claim.
+ */
+export interface ComparisonVerdict {
+  chooseSim: string
+  chooseCompetitor: string
+}
+
+export function buildBottomLine(competitor: CompetitorProfile): ComparisonVerdict {
+  const strength = competitor.standoutFeatures[0]
+  const chooseCompetitor = strength
+    ? `Choose ${competitor.name} if you specifically need ${lowercaseFirst(strength.title)}: ${strength.description}`
+    : `Choose ${competitor.name} if its specific strengths, documented above, matter more to your team than an AI-native, self-hostable workspace.`
+
+  return {
+    chooseSim: `Choose Sim if you want an open-source, self-hostable AI workspace that treats AI agents as first-class citizens: native multi-LLM support, real-time multiplayer editing, environment promotion (dev/qa/prod), human-in-the-loop approvals, and enterprise governance (SSO, credential-level permissions, audit logs) built in rather than bolted on.`,
+    chooseCompetitor,
+  }
+}
+
+/**
+ * Builds the FAQ set for a "Sim vs {Competitor}" page. Answer-first, each
+ * question/answer pair is independently quotable per the landing GEO rules,
+ * and every answer names "Sim" and the competitor explicitly. Every answer
+ * draws on a real, sourced {@link Fact} field rather than a generic claim,
+ * and no two questions repeat the same answer.
+ */
+export function buildComparisonFaqs(competitor: CompetitorProfile): ComparisonFaq[] {
+  const name = competitor.name
+  const facts = competitor.facts
+  const faqs: ComparisonFaq[] = [
+    {
+      question: `Is Sim a good alternative to ${name}?`,
+      answer: `Sim is an open-source AI workspace where teams build, deploy, and manage AI agents visually, conversationally, or with code. ${name} is ${lowercaseFirst(competitor.oneLiner)} Teams considering a switch typically weigh licensing (Sim is Apache 2.0 and self-hostable), pricing model, and how AI-native the platform's agent-building experience is.`,
+    },
+    {
+      question: `What is the main difference between Sim and ${name}?`,
+      answer: buildKeyDifferenceAnswer(competitor),
+    },
+    {
+      question: `Does Sim support self-hosting compared to ${name}?`,
+      answer: `Sim can be self-hosted via Docker or Kubernetes under an Apache 2.0 license, in addition to a managed cloud-hosted plan. ${name}'s self-hosting position: ${ensurePeriod(firstSentence(facts.platform.selfHostOption.value))}`,
+    },
+    {
+      question: `How does Sim's pricing compare to ${name}?`,
+      answer: `Sim uses ${summarizeFact(simProfile.facts.pricing.pricingModel.value)} ${name} uses ${summarizeFact(facts.pricing.pricingModel.value)}`,
+    },
+    {
+      question: `Is Sim more secure than ${name}?`,
+      answer: `Security is a like-for-like comparison, not a one-line verdict. Sim: ${summarizeFact(simProfile.facts.security.additionalCompliance.value)} ${name}: ${summarizeFact(facts.security.additionalCompliance.value)} Check the Security & compliance rows above for the full breakdown, including SSO, audit logging, and data residency.`,
+    },
+    {
+      question: `Which has stronger AI agent capabilities, Sim or ${name}?`,
+      answer: `Sim: ${summarizeFact(simProfile.facts.aiCapabilities.multiLlmSupport.value)} ${name}: ${summarizeFact(facts.aiCapabilities.multiLlmSupport.value)} Sim also ships native human-in-the-loop approvals, a hybrid vector-plus-keyword knowledge base, and an in-editor AI Copilot that can read execution logs and directly edit the workflow to fix a failed run.`,
+    },
+    {
+      question: `What are ${name}'s documented limitations compared to Sim?`,
+      answer: buildLimitationAnswer(competitor),
+    },
+    {
+      question: `Can I migrate from ${name} to Sim?`,
+      answer: `There is no automated one-click migration tool between ${name} and Sim. Workflows and automations need to be rebuilt in Sim's visual builder, natural-language Chat surface, or API. Most teams start by recreating their highest-value automation first to validate the switch before migrating the rest.`,
+    },
+  ]
+
+  if (competitor.isWorkflowBuilder === false) {
+    faqs.push({
+      question: `Is ${name} a workflow builder like Sim?`,
+      answer: `Not in the same sense. ${competitor.oneLiner} Sim, by contrast, is a visual and code-based workflow builder that deploys agents as REST APIs, scheduled jobs, or chat interfaces, so the two solve different parts of the AI agent problem rather than competing feature-for-feature.`,
+    })
+  }
+
+  return faqs
+}
+
+function buildKeyDifferenceAnswer(competitor: CompetitorProfile): string {
+  const topFeature = competitor.standoutFeatures[0]
+  const topLimitation = competitor.limitations[0]
+  const parts = [
+    `Sim is built specifically as an AI agent workspace, with native multi-LLM support, an in-editor AI Copilot, and a knowledge base with hybrid vector + keyword search.`,
+  ]
+  if (topFeature) {
+    parts.push(`${competitor.name}'s standout capability is ${formatClaim(topFeature)}`)
+  }
+  if (topLimitation) {
+    parts.push(`One documented limitation of ${competitor.name} is ${formatClaim(topLimitation)}`)
+  }
+  return parts.join(' ')
+}
+
+/**
+ * A dedicated "what's wrong with the competitor" answer, distinct from
+ * {@link buildKeyDifferenceAnswer} (which leads with Sim's own strengths).
+ * Walks every documented limitation rather than just the first, so the
+ * answer stays substantive even for a two-limitation profile.
+ */
+function buildLimitationAnswer(competitor: CompetitorProfile): string {
+  if (competitor.limitations.length === 0) {
+    return `No specific limitations of ${competitor.name} are documented in this comparison yet. See the feature-by-feature table above for a full side-by-side of every category.`
+  }
+  const parts = competitor.limitations.map(formatClaim)
+  return `Documented limitations of ${competitor.name} include ${parts.join('; ')}`
+}
+
+/** Renders a titled claim (a standout feature or limitation) as "lowercased title: description". */
+function formatClaim(item: { title: string; description: string }): string {
+  return `${lowercaseFirst(item.title)}: ${item.description}`
+}
+
+function firstSentence(value: string): string {
+  const match = value.match(/^[^.]+\./)
+  return match ? match[0] : value
+}
+
+/** Appends a period if `value` doesn't already end in sentence-closing punctuation. */
+export function ensurePeriod(value: string): string {
+  return /[.!?]$/.test(value) ? value : `${value}.`
+}
+
+/** Lowercases the first letter of `value`, unless it starts with an acronym (e.g. "AI", "SSO", "MCP"). */
+export function lowercaseFirst(value: string): string {
+  if (value.length === 0) return value
+  // Leave a leading acronym (2+ consecutive capitals, e.g. "AI", "SSO", "MCP") alone.
+  if (/^[A-Z]{2,}/.test(value)) return value
+  return value.charAt(0).toLowerCase() + value.slice(1)
+}
+
+/**
+ * Composes {@link firstSentence} + {@link lowercaseFirst} + {@link ensurePeriod} for
+ * stitching a fact value mid-sentence. Strips a leading "Yes:"/"No:" token first so
+ * boolean facts don't produce mid-sentence "yes: ..."/"no: ..." fragments.
+ */
+function summarizeFact(value: string): string {
+  const stripped = value.replace(/^(Yes|No)(?![a-zA-Z])(?::\s*)?/, '').trim()
+  const base = stripped.length > 0 ? stripped : value
+  return ensurePeriod(lowercaseFirst(firstSentence(base)))
+}

apps/sim/app/(landing)/components/footer/footer.tsx

@@ -40,6 +40,7 @@ const PRODUCT_LINKS: FooterItem[] = [
 const RESOURCES_LINKS: FooterItem[] = [
   { label: 'Blog', href: '/blog' },
   { label: 'Docs', href: 'https://docs.sim.ai', external: true },
+  { label: 'Compare', href: '/comparison' },
   { label: 'Partners', href: '/partners' },
   { label: 'Careers', href: '/careers' },
   { label: 'Changelog', href: '/changelog' },

apps/sim/app/sitemap.ts

@@ -3,6 +3,11 @@ import { COURSES } from '@/lib/academy/content'
 import { getAllPostMeta } from '@/lib/blog/registry'
 import { SITE_URL } from '@/lib/core/utils/urls'
 import { INTEGRATIONS, INTEGRATIONS_UPDATED_AT } from '@/lib/integrations'
+import {
+  ALL_COMPETITORS,
+  getLatestVerifiedDate,
+  SIM_LATEST_VERIFIED,
+} from '@/app/(landing)/comparison/utils'
 import { ALL_CATALOG_MODELS, MODEL_PROVIDERS_WITH_CATALOGS } from '@/app/(landing)/models/utils'
 
 /**
@@ -148,6 +153,24 @@ export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
     })),
   ]
 
+  // Matches the max(Sim, competitor) verified-date logic each detail page's own
+  // JSON-LD `dateModified` uses, so the sitemap timestamp never lags behind it.
+  const competitorLastModified = (competitor: (typeof ALL_COMPETITORS)[number]) =>
+    new Date(Math.max(SIM_LATEST_VERIFIED.getTime(), getLatestVerifiedDate(competitor).getTime()))
+
+  const comparisonLastModified =
+    ALL_COMPETITORS.length > 0
+      ? new Date(Math.max(...ALL_COMPETITORS.map((c) => competitorLastModified(c).getTime())))
+      : SIM_LATEST_VERIFIED
+
+  const comparisonPages: MetadataRoute.Sitemap = [
+    { url: `${baseUrl}/comparison`, lastModified: comparisonLastModified },
+    ...ALL_COMPETITORS.map((competitor) => ({
+      url: `${baseUrl}/comparison/${competitor.id}`,
+      lastModified: competitorLastModified(competitor),
+    })),
+  ]
+
   return [
     ...staticPages,
     ...blogPages,
@@ -156,5 +179,6 @@ export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
     ...providerPages,
     ...modelEntries,
     ...academyPages,
+    ...comparisonPages,
   ]
 }

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

@@ -0,0 +1,842 @@
+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 creating LLM chains, RAG pipelines, and multi-agent AI workflows, offered as self-hosted software or a managed cloud service, and owned by Workday since August 2025.',
+  standoutFeatures: [
+    {
+      title: 'Native RAG / Document Store pipeline',
+      description:
+        "Flowise's Document Store handles the full RAG pipeline in one place. It offers multiple document loaders, 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, per-chunk editing, and upsert into a wide range of vector store backends.",
+      shortDescription:
+        'Native RAG pipeline with the broadest built-in text-splitter and chunking options.',
+      source: {
+        url: 'https://docs.flowiseai.com/using-flowise/document-stores',
+        label: 'Flowise Docs: Document Stores',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'Agentflow V2 with built-in human-in-the-loop and evaluation',
+      description:
+        'Agentflow V2 supports loops, conditional branching, and a dedicated Human Input node that pauses execution for approve/reject feedback before sensitive tool calls (bookings, sends, orders) proceed. Flowise also ships a built-in Evaluations feature that runs chatflows/agentflows against a dataset and scores outputs with string, numeric, or LLM-as-judge evaluators, reporting pass/fail rate, average tokens, and latency.',
+      shortDescription:
+        'Native human-approval node plus built-in dataset-based LLM-judge evaluation reporting.',
+      source: {
+        url: 'https://docs.flowiseai.com/tutorials/human-in-the-loop',
+        label: 'Flowise Docs: Human In The Loop',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'Large open-source project with Apache 2.0 core',
+      description:
+        "Flowise's Community Edition is Apache License 2.0, and its GitHub repo has roughly 54,000 stars. It has an active Discord community and supports full self-hosting via Docker.",
+      shortDescription:
+        'Apache 2.0 licensed, ~54k GitHub stars, actively maintained open-source project.',
+      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 only 37% on "Enterpriseness," versus 63% on "Codability." The report cites 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. There is no built-in real-time co-editing (like Google Docs) of the same chatflow, and community members have requested true multi-user collaborative editing as a feature.",
+      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',
+        asOf: '2026-07-02',
+      },
+    },
+  ],
+  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 dedicated natural-language "describe it and I\'ll build it" flow generator documented.',
+        detail: 'No confirmed natural-language workflow generation feature.',
+        shortValue: 'Visual canvas plus custom-code nodes',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/integrations/utilities/custom-js-function',
+            label: 'Flowise Docs: Custom JS Function',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      learningCurve: {
+        value:
+          'Marketed as low-code/no-code and approachable for non-technical users via templates and drag-and-drop nodes, but third-party review found 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 source 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 that supports 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 (e.g. 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. Enterprise-only modules (SSO, RBAC, audit logs, organization workspaces) ship under a separate Commercial License.",
+        shortValue: 'Apache 2.0 (core), commercial license for enterprise modules',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://github.com/FlowiseAI/Flowise/blob/main/LICENSE.md',
+            label: 'GitHub: Flowise LICENSE.md',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://github.com/FlowiseAI/Flowise/issues/5164',
+            label: 'GitHub Issue #5164: Clarify Licensing Terms for Community vs Enterprise Code',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      environmentPromotion: {
+        value:
+          "Unknown: no public documentation found describing 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. There is no documented live, multi-cursor editing of the same flow, and this has been an open community feature request.",
+        detail:
+          'Cloud/Enterprise multi-user features (workspaces, RBAC) govern access, not concurrent editing.',
+        shortValue: 'No live multi-user concurrent canvas editing',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://github.com/FlowiseAI/Flowise/issues/2661',
+            label: 'GitHub Issue #2661: Multi User Support',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      nativeFileStorage: {
+        value:
+          "Unknown: no public documentation found of a general-purpose file storage system with folder hierarchy, link-sharing with access controls, and 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 public documentation found of a native spreadsheet-like data table feature with row/column limits and keyboard navigation. 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 public documentation found of an inline rich-text/WYSIWYG markdown editor for documents stored in Flowise.',
+        shortValue: 'Unknown, not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+    },
+    aiCapabilities: {
+      multiLlmSupport: {
+        value:
+          'Yes: Flowise integrates a broad set of LLM providers including OpenAI, Azure OpenAI, AWS Bedrock, Google PaLM/Vertex AI, Cohere, HuggingFace Inference, Ollama, Replicate, and Anthropic models (e.g. Claude 3.5/4), 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',
+          },
+        ],
+      },
+      agentReasoningBlocks: {
+        value:
+          "Yes: Flowise's Agentflow V2 provides dedicated Agent nodes plus orchestration primitives (Condition, Iteration, Human Input) for building 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:
+          'Unknown: no public documentation found of a feature letting a user describe an automation in plain language and have Flowise generate or edit the flow automatically.',
+        shortValue: 'Unknown, not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      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 as 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. No separate, dedicated "guardrail validation" block was documented 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 no dedicated, built-in image, video, or text-to-speech generation node was found in the standard node library as of this research.',
+        detail:
+          'Community discussions (e.g. GitHub issues) show text-to-speech and native image generation as requested but not confirmed 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 only calling 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 public documentation found of 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 public documentation found of a reusable, named prompt/knowledge-snippet feature invoked by reference across multiple agents, distinct from a one-off system prompt or Variables feature.',
+        detail:
+          'Flowise does have a general Variables feature (static/runtime key-value) but this 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), in addition to 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" with individual chunk editing). The 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 users and Flowise's own issue tracker report that the execution engine processes the queue one node at a time and does not run parallel branches concurrently, causing 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), not a shipped capability. Flowise supports MCP for tool-calling but has no documented 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',
+          },
+        ],
+      },
+    },
+    integrations: {
+      integrationCount: {
+        value:
+          'Flowise documents integration categories across LLMs, vector stores, document loaders, embeddings, tools, and MCP servers (referred to internally as "nodes"), but no official, currently-published exact total node/integration count was found.',
+        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. No dedicated cron/schedule trigger, or broad library of app-specific event triggers, was found documented.',
+        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. No dedicated Python code-step node was found documented.',
+        shortValue: 'Yes, custom JavaScript function/tool nodes; no native Python step found',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.flowiseai.com/integrations/utilities/custom-js-function',
+            label: 'Flowise Docs: Custom JS Function',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      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. No public, first-party marketplace for community-built node plugins was found 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 own documentation covers only consuming external MCP servers as an MCP client; no documented capability exists 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 a native Flowise feature.',
+        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:
+          "Pricing sourced from third-party aggregator coverage, not Flowise's own pricing page (which returned a login wall during this research); treat as estimated.",
+        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. No SOC 2 report, badge, or trust page was found published by Flowise itself, so this claim is unverified.',
+        detail:
+          'Treat with skepticism: the same third-party source also claims FedRAMP and PCI compliance for a small startup, which is atypical and could not be corroborated on flowiseai.com.',
+        shortValue: 'Unverified third-party claim, 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; no dedicated regional-cloud-hosting option was documented 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 unverified third-party SOC 2 claim, no official Flowise-published documentation of HIPAA, ISO 27001, PCI, or FedRAMP certification was found.',
+        shortValue: 'Unknown, no official certifications published',
+        confidence: 'unknown',
+        sources: [],
+      },
+      modelAndToolGovernance: {
+        value:
+          "Unknown: no public documentation found of admin controls restricting which specific LLM providers/models or which tools/integrations a given role may use; Flowise's documented 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 no documentation was found of restricting 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 is not cleanly supported out of the box and requires workarounds.',
+        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 public documentation found of org-configurable retention windows for execution logs or soft-deleted resources.',
+        shortValue: 'Unknown, not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      piiRedaction: {
+        value:
+          'Unknown: no public documentation found of a dedicated 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 there is 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',
+          },
+        ],
+      },
+    },
+    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 public documentation found describing automatic retries, checkpointing, or replay of a past execution with its original inputs.',
+        shortValue: 'Unknown, not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      failureAlerting: {
+        value:
+          'Unknown: no public documentation found of 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 no documentation was found of exporting 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. No clear public documentation of a poll-for-result async API pattern was found.',
+        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: no published, verified numbers were found 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 no dedicated "catch/error-handler" node distinct from conditional routing was documented.',
+        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',
+          },
+        ],
+      },
+    },
+    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 (reported as 99.99% uptime) is offered on the Enterprise plan according to third-party coverage; no SLA is documented for lower tiers.',
+        detail: 'Not independently confirmed on an official Flowise SLA page.',
+        shortValue: 'Yes, ~99.99% SLA claimed on Enterprise plan',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.aicuflow.com/blog/enterprise-ai-sso-rbac-audit',
+            label: 'Aicuflow: Enterprise AI Platform with SSO, Role-Based Access, and Audit Trails',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      community: {
+        value:
+          "Flowise's GitHub repository has approximately 54,000 stars (Apache 2.0 licensed core), with an active Discord community; exact Discord member counts were 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:
+          'No official Flowise-run academy or certification program was found; 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,883 @@
+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: 'Dual-direction MCP support',
+      description:
+        'Langflow can act as an MCP client, connecting to external MCP servers as tool sources. It also automatically exposes every flow with a Chat Output as its own MCP server, so any flow becomes a callable tool for outside MCP clients.',
+      shortDescription: 'Both consumes external MCP servers and publishes flows as MCP servers.',
+      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 concurrently co-edit the same flow with live cursors or synced operations today. There is an open community feature request for real-time collaboration similar to Figma or n8n. Current practice is exporting flows as JSON and merging changes like code, or using a shared 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. The report cites gaps in agent sandboxing, security guardrail maturity, and evaluation frameworks, based on publicly documented capabilities.",
+      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 where users connect components into a flow. Every component's Python source is also 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, an open-source permissive 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 collaborative multi-user editing of the same flow is not currently available. It is an open community feature request, and 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 was found describing 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: [],
+      },
+    },
+    aiCapabilities: {
+      multiLlmSupport: {
+        value:
+          "Langflow supports configuring multiple LLM providers globally via Settings > Model Providers, each with its own API key, including documented support for 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 fully 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 was found describing built-in image, video, or audio generation components. Community discussions show users integrating image generation via custom components or external APIs rather than a native block.',
+        shortValue: 'Unknown, no native generative media blocks documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      dynamicToolUse: {
+        value:
+          "Yes: Langflow agents receive a registered list of tools at setup, and the connected LLM decides at run time which registered tool to call based on each tool's description. This includes flows exposed as tools and MCP-server tools.",
+        detail: 'Tool pool is whatever is registered to that agent, not the entire platform.',
+        shortValue: 'Yes, agent picks among registered tools at inference',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.langflow.org/agents-tools',
+            label: 'Langflow Docs: Configure tools for agents',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      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 dedicated fan-out/fan-in feature is documented. Langflow builds a flow into a Directed Acyclic Graph and executes nodes in dependency order, with each node built and run using the results of the nodes it depends on, which describes sequential DAG traversal rather than 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) rather than a merged feature, and the only available paths to A2A interoperability are 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',
+          },
+        ],
+      },
+    },
+    integrations: {
+      integrationCount: {
+        value:
+          "Langflow organizes third-party integrations as component bundles grouped by provider, such as Google, OpenAI, LangChain, Elastic, and Composio. The docs state the full current list of bundles and components is only visible in the running app's Bundles panel, not fully 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 paid or curated marketplace documented, unlike a dedicated app store.',
+        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 dollars per month for higher usage limits, and separate enterprise pricing, though Langflow's own official pricing page content was not directly retrievable during this research.",
+        detail:
+          'Third-party pricing summaries used since the official pricing page could not be directly verified.',
+        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 could not be verified directly from Langflow's own official pricing page. Third-party summaries cite a cloud paid tier starting around 25 dollars per month, but this is not confirmed against an official Langflow source.",
+        detail: 'Official pricing page was not accessible during research.',
+        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 is reported to offer a free account tier to get started 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 Langflow documentation or official page was found stating a SOC 2 certification for Langflow itself. The docs' Security page discusses infrastructure-level responsibility for operators rather than 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: because Langflow can be fully self-hosted on Docker, Kubernetes, on-prem, or any cloud region, organizations can control data residency entirely themselves. No dedicated managed regional-hosting product was found documented for Langflow Cloud specifically.',
+        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 was found 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 found cover API-key-based authentication, and third-party summaries mention SSO as a roadmap item rather than 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: [],
+      },
+    },
+    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, suggesting some support for background triggering and later status checks. A dedicated async job-polling API pattern was not fully detailed in the docs retrieved.',
+        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: no concrete published numbers for maximum single-execution duration or concurrent run limits were found in Langflow's official documentation. 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: [],
+      },
+    },
+    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 as of this research, alongside an active public Discord server. It is frequently described in industry coverage 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: no official Langflow-run structured course, certification, or academy program was found. Third-party paid courses exist on platforms like Udemy that teach LangChain and Langflow, but these are not 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/competitors/stackai.ts

@@ -0,0 +1,940 @@
+import { StackAIIcon } 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 stackaiProfile: CompetitorProfile = {
+  id: 'stack-ai',
+  name: 'StackAI',
+  website: 'https://www.stack-ai.com',
+  brand: {
+    icon: StackAIIcon,
+    selfFramed: true,
+    colors: ['#8c8c8c', '#212121', '#d0d0d0'],
+    source: 'Context.dev brand-intelligence API',
+    asOf: '2026-07-02',
+  },
+  oneLiner:
+    'StackAI is a proprietary, enterprise-focused visual platform for building, deploying, and governing AI agents. It connects LLMs and business systems through a drag-and-drop, low-code node builder.',
+  standoutFeatures: [
+    {
+      title: 'Agentic Development Life Cycle (dev/staging/production promotion)',
+      description:
+        'StackAI provides three default, isolated environments (development, staging, production), plus custom environments. Promotion between them is gated by pull requests, each environment can connect to its own data sources, and an admin approval queue sits before production deploys.',
+      shortDescription: 'PR-gated dev/staging/production promotion with admin approval queues.',
+      source: {
+        url: 'https://www.stackai.com/blog/the-agentic-development-life-cycle-how-to-manage-ai-agents-at-scale',
+        label: 'The Agentic Development Life Cycle - StackAI blog',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'Version history with diff/compare and rollback',
+      description:
+        'Every save creates a full version snapshot of an agent. A comparison tool shows added or removed nodes, prompt and LLM config changes, and connection changes. Any version can be reverted, and reverting creates a new version rather than erasing history.',
+      shortDescription: 'Full version snapshots with diff/compare and one-click rollback.',
+      source: {
+        url: 'https://www.stackai.com/blog/the-agentic-development-life-cycle-how-to-manage-ai-agents-at-scale',
+        label: 'The Agentic Development Life Cycle - StackAI blog',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'Human-in-the-loop approval gating before side effects',
+      description:
+        'A workflow can pause at a decision point and send an approval request, for example via Slack, Teams, or email, before a risky action like sending an email, writing to a database, or provisioning access. The run resumes once a human approves, rejects, or gives feedback.',
+      shortDescription: 'Pauses workflows for human approval before risky tool calls execute.',
+      source: {
+        url: 'https://www.stackai.com/blog/introducing-stackai-human-in-the-loop-agentic-workflows-you-can-trust',
+        label: 'Introducing StackAI Human-in-the-Loop - StackAI blog',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'On-prem / VPC self-hosted deployment for enterprise',
+      description:
+        "The Enterprise plan supports on-premise or VPC deployment behind the customer's own VPN/network, alongside dedicated infrastructure and SSO/access controls.",
+      shortDescription: 'Enterprise-only on-prem or VPC deployment with dedicated infrastructure.',
+      source: {
+        url: 'https://www.stackai.com/pricing',
+        label: 'StackAI Pricing',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'SOC 2 Type II and ISO 27001 certified, with a public Trust Center',
+      description:
+        'StackAI publishes a Trust Center (trust.stackai.com) documenting SOC 2 Type II and ISO 27001 certification, third-party penetration test results, and DPAs with OpenAI and Anthropic.',
+      shortDescription: 'Public Trust Center with SOC 2, ISO 27001, and pen test results.',
+      source: {
+        url: 'https://trust.stackai.com/',
+        label: 'StackAI Trust Center',
+        asOf: '2026-07-02',
+      },
+    },
+  ],
+  limitations: [
+    {
+      title: 'Not open source',
+      description:
+        'StackAI is a proprietary, closed-source commercial SaaS platform; its GitHub organization contains only auxiliary tools/integrations, not the core platform, so there is no self-hostable OSS codebase to audit or fork.',
+      shortDescription: 'Closed-source SaaS with no auditable or forkable codebase.',
+      source: {
+        url: 'https://github.com/stackai',
+        label: 'StackAI GitHub organization',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'Free tier is very limited',
+      description:
+        'The free plan caps usage at 500 runs/month, 2 projects, and 1 seat, with support limited to community Discord. Far below what a team evaluating agent workflows at scale would need.',
+      shortDescription: 'Free plan caps at 500 runs, 2 projects, 1 seat.',
+      source: {
+        url: 'https://www.stackai.com/pricing',
+        label: 'StackAI Pricing',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'No published self-serve/mid-tier pricing',
+      description:
+        'Beyond the free tier, StackAI publishes only a custom-quote Enterprise plan with no visible mid-market pricing tier, making cost comparison opaque without contacting sales.',
+      shortDescription: 'No mid-tier pricing. Only free or a custom Enterprise quote.',
+      source: {
+        url: 'https://www.stackai.com/pricing',
+        label: 'StackAI Pricing',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'HIPAA/GDPR not documented on the Trust Center itself',
+      description:
+        'The public Trust Center page lists only SOC 2 Type II and ISO 27001. A separate blog post confirms StackAI was also audited against HIPAA, but GDPR compliance appears only on marketing/pricing pages (e.g. "SOC 2, HIPAA & GDPR compliance" on the Enterprise tier) with no dedicated audit evidence found. The compliance story is split across sources instead of consolidated in one place.',
+      shortDescription:
+        'HIPAA is audited but GDPR compliance is undocumented outside marketing pages.',
+      source: {
+        url: 'https://trust.stackai.com/',
+        label: 'StackAI Trust Center',
+        asOf: '2026-07-02',
+      },
+    },
+  ],
+  facts: {
+    platform: {
+      builderType: {
+        value: 'Visual/low-code node-based workflow builder',
+        detail:
+          'Drag-and-drop canvas of nodes (LLM, tools, logic, multimodal) for building agents; also supports Python code nodes for custom logic.',
+        shortValue: 'Drag-and-drop nodes plus Python code nodes',
+        confidence: 'verified',
+        sources: [
+          { url: 'https://docs.stackai.com/', label: 'StackAI Docs Overview', asOf: '2026-07-02' },
+          {
+            url: 'https://docs.stackai.com/logic/python-code',
+            label: 'Python Code node - StackAI Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      learningCurve: {
+        value: 'Unknown',
+        shortValue: 'Not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      selfHostOption: {
+        value: 'Yes, on the Enterprise plan only',
+        detail:
+          "On-premise or VPC deployment, entirely within the customer's own VPC and behind their own VPN, is offered as part of the custom-priced Enterprise tier. Not available on the free tier.",
+        shortValue: 'Enterprise-only, VPC or on-prem',
+        confidence: 'verified',
+        sources: [
+          { url: 'https://www.stackai.com/pricing', label: 'StackAI Pricing', asOf: '2026-07-02' },
+          {
+            url: 'https://www.stackai.com/solutions/self-hosted',
+            label: 'StackAI Self-Hosted Solutions page',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      deploymentOptions: {
+        value: 'Cloud SaaS, VPC/on-prem (Enterprise), plus an AWS Marketplace listing',
+        detail:
+          'Agents deploy to chat, forms, APIs, Slack, Teams, or batch run; also listed on AWS Marketplace as "StackAI Hosted".',
+        shortValue: 'Cloud, VPC/on-prem, AWS Marketplace',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://aws.amazon.com/marketplace/pp/prodview-p6pd4dwnmgyew',
+            label: 'StackAI Hosted - AWS Marketplace',
+            asOf: '2026-07-02',
+          },
+          { url: 'https://www.stackai.com/pricing', label: 'StackAI Pricing', asOf: '2026-07-02' },
+        ],
+      },
+      templates: {
+        value: 'Yes, template library across business functions',
+        detail:
+          'Pre-built templates for finance/compliance, business operations, customer service/support, sales, and more.',
+        shortValue: 'Templates across business functions',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://www.stackai.com/templates',
+            label: 'Customizable AI Workflow Templates - StackAI',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      license: {
+        value: 'Proprietary / closed source',
+        detail:
+          'Commercial SaaS platform; the GitHub org (github.com/stackai) contains only auxiliary repos, not the core platform.',
+        shortValue: 'Closed-source commercial SaaS',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://github.com/stackai',
+            label: 'StackAI GitHub organization',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      environmentPromotion: {
+        value: 'Yes: full dev/staging/production workspace promotion with PR-gated approval',
+        detail:
+          'Three default isolated environments (development, staging, production), each independently connectable to different data sources/APIs; changes flow via pull requests that must be reviewed and approved before promotion, with a central admin approval queue. Custom environments (QA, experimentation, demo, client-specific) can be added.',
+        shortValue: 'Dev/staging/prod with PR-gated promotion',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://www.stackai.com/blog/the-agentic-development-life-cycle-how-to-manage-ai-agents-at-scale',
+            label: 'The Agentic Development Life Cycle - StackAI blog',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      versionControlDepth: {
+        value:
+          'Version history with diff/compare and rollback via revert; no branching or client-side undo/redo',
+        detail:
+          'Every save creates a full version snapshot; a compare tool diffs nodes, prompts/LLM config, and connections between versions. Any version can be reverted, which creates a new version and preserves history.',
+        shortValue: 'Version history, diff, and rollback',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://www.stackai.com/blog/the-agentic-development-life-cycle-how-to-manage-ai-agents-at-scale',
+            label: 'The Agentic Development Life Cycle - StackAI blog',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      realtimeCollaboration: {
+        value:
+          'Unknown: one third-party review vaguely claims "real-time collaboration features," but no official StackAI documentation confirms live, concurrent multi-user editing (synced cursors, selections, live edits) on the same workflow canvas.',
+        detail:
+          'StackAI documents workspace and folder sharing with role-based access to projects. That is async collaboration, not verified simultaneous co-editing with presence indicators.',
+        shortValue: 'Unknown, not confirmed in official docs',
+        confidence: 'unknown',
+        sources: [],
+      },
+      nativeFileStorage: {
+        value:
+          'No: the Files node is a per-workflow input for uploading a document as context for the LLM, not a persistent file store. Ongoing file access goes through Knowledge Base connectors to external storage like Google Drive, Dropbox, OneDrive, SharePoint, Box, S3, or Azure Blob. No evidence was found of a native file system with its own folder hierarchy, link-based sharing, or a trash/recovery feature.',
+        detail:
+          'Workspace "folders" that exist in StackAI docs organize projects/permissions, not user files.',
+        shortValue: 'No, relies on external storage connectors',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/workflow-builder/inputs/files-node',
+            label: 'Files Node docs',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.stackai.com/governance-and-security/workspace-and-folder-access',
+            label: 'Workspace and Folder Access docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      dataTables: {
+        value:
+          "No: the Table node lets a workflow upload a CSV or XLSX file and query it with LLM-generated SQL, but only as a one-off input to that workflow run. That's different from a persistent, spreadsheet-like data table shared across a workspace, with defined row/column limits and spreadsheet-style keyboard navigation.",
+        detail:
+          'No evidence of a standalone "Tables" product surface with persistent grid storage independent of a single workflow run.',
+        shortValue: 'No, only per-workflow CSV analysis',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.stackai.com/blog/how-to-build-spreadsheet-ai-agent',
+            label: 'Build Spreadsheet AI Agent blog',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      richTextEditor: {
+        value:
+          'Unknown: no public StackAI documentation describes an inline rich-text or WYSIWYG markdown editor for documents stored in the platform. Searches only surfaced unrelated third-party products with similar names.',
+        shortValue: 'Unknown, not publicly documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+    },
+    aiCapabilities: {
+      multiLlmSupport: {
+        value: 'Yes, broad support across major LLM providers',
+        detail:
+          'Marketed as supporting a wide range of LLMs, with documented data processing agreements in place with OpenAI and Anthropic.',
+        shortValue: 'Broad LLM provider support',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://trust.stackai.com/',
+            label: 'StackAI Trust Center (OpenAI/Anthropic DPAs)',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      agentReasoningBlocks: {
+        value: 'Unknown',
+        shortValue: 'Not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      naturalLanguageBuilding: {
+        value: 'Unknown',
+        shortValue: 'Not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      knowledgeBaseRag: {
+        value: 'Yes: knowledge base / data loader connections',
+        detail:
+          'Connects to knowledge bases, tools, and business systems; the Enterprise plan includes all data loaders.',
+        shortValue: 'Knowledge base and data loader nodes',
+        confidence: 'verified',
+        sources: [
+          { url: 'https://docs.stackai.com/', label: 'StackAI Docs Overview', asOf: '2026-07-02' },
+          { url: 'https://www.stackai.com/pricing', label: 'StackAI Pricing', asOf: '2026-07-02' },
+        ],
+      },
+      mcpSupport: {
+        value: 'Yes: dedicated MCP node',
+        detail:
+          'An MCP node lets a workflow call a tool on a Model Context Protocol server, using public servers via URL connection or self-hosted/local MCP servers exposed via a tunnel (e.g. ngrok) for advanced users.',
+        shortValue: 'Dedicated MCP node',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/workflow-builder/apps/mcp',
+            label: 'MCP - StackAI Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      evaluationGuardrails: {
+        value:
+          "Guardrails such as retrieval grounding, tool-call validation, and output enforcement are covered in vendor guidance, but there's no dedicated first-party evaluation or guardrails product feature.",
+        shortValue: 'Guardrail guidance, no dedicated product',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.stackai.com/insights/how-to-design-ai-agent-guardrails-best-practices-for-input-validation-output-filtering-and-safety-controls',
+            label: 'How to Design AI Agent Guardrails - StackAI insights',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      humanInTheLoop: {
+        value: 'Yes: dedicated pause-and-approve mechanism distinct from a simple delay step',
+        detail:
+          'A workflow pauses at a decision point and sends an approval request via Slack, Teams, email, or another connected channel. A human reviewer can approve, reject, or give feedback, and the gated action, such as sending an email, writing to a database, or provisioning access, only executes after approval. This checkpoint reduces the damage a hallucination or a mistaken tool call could cause.',
+        shortValue: 'Pause-and-approve checkpoint before side effects',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://www.stackai.com/blog/introducing-stackai-human-in-the-loop-agentic-workflows-you-can-trust',
+            label: 'Introducing StackAI Human-in-the-Loop - StackAI blog',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      generativeMedia: {
+        value: 'Yes: image and audio generation nodes; no dedicated video generation node',
+        detail:
+          'A Text-to-Audio node uses ElevenLabs for TTS and voice cloning; an Image node generates images from text prompts using models such as OpenAI DALL·E 3 or Stable Diffusion.',
+        shortValue: 'Image and audio nodes, no video',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.stack-ai.com/stack-ai/workflow-builder/outputs/image-node',
+            label: 'Image Node - StackAI Docs',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.stack-ai.com/docs/builder-guide/actions/text-to-audio',
+            label: 'Text to Audio - StackAI Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      dynamicToolUse: {
+        value: 'Unknown',
+        shortValue: 'Not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      modelFallback: {
+        value: 'Unknown',
+        shortValue: 'Not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      agentSkills: {
+        value:
+          'Yes: StackAI has a Prompt Library where builders save and reuse named prompts/instructions (e.g. a saved "Market Analyst Persona") across agents, rather than re-writing a one-off system prompt each time.',
+        detail:
+          'Documented as a prompt/instruction library, not explicitly branded as "skills" with structured knowledge attachments the way some competitors frame it.',
+        shortValue: 'Yes, via reusable Prompt Library',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/other-views/prompt-library',
+            label: 'Prompt Library docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      nativeChatDeployment: {
+        value:
+          'Yes: builders can publish a workflow or agent as a hosted Chat Assistant interface, alongside form, batch run, Slack, Teams, and API deployment targets. A chat widget can also be embedded on external sites via a copy-paste snippet.',
+        shortValue: 'Yes, native chat + embeddable widget',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/welcome-to-stackai/overview/platform-overview',
+            label: 'Platform Overview',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.stackai.com/getting-started/start-here',
+            label: 'Start Here',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      kbChunkVisibility: {
+        value:
+          "Yes: StackAI's Knowledge Base nodes return retrieved chunks and let builders configure the chunking algorithm, chunk length, and chunk overlap. An output-format toggle switches between chunks, pages, and full documents, and a document preview view lets builders inspect indexed content.",
+        detail:
+          "Confirms chunk-level granularity is exposed (algorithm, length, overlap, chunk vs page vs doc output); a dedicated chunk-index inline debugging pane specifically wasn't independently verified beyond the document preview.",
+        shortValue: 'Yes, chunk-level config and output',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/best-practices/chunking',
+            label: 'Chunking docs',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.stackai.com/workflow-builder/apps/knowledge-base',
+            label: 'Knowledge Base docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      parallelExecution: {
+        value:
+          "Partial: StackAI's core workflow builder is built around sequential and conditional (If/Else) branching rather than a dedicated deterministic fan-out/fan-in node. Concurrent execution shows up at the AI Agent node level, where the agent can call multiple Subflow Tools in parallel (e.g., checking several independent systems at once) and StackAI Project nodes can run in parallel under loop mode.",
+        detail:
+          'No standalone "split into parallel paths" or "parallel branches" node was found in the core logic node set (If/Else, Loop Subflow); parallelism instead comes from agent-driven concurrent tool calls or parallel sub-project execution inside a loop, which is a narrower mechanism than a general-purpose fan-out/fan-in workflow node.',
+        shortValue: 'Partial, via parallel tool calls and loop mode',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/workflow-builder/core-nodes/ai-agent-node/subflow-tools',
+            label: 'Subflow Tools docs',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.stackai.com/workflow-builder/utils-logic-and-others/logic/loop-subflow',
+            label: 'Loop Subflow docs',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.stack-ai.com/stack-ai/logic/if-else-node',
+            label: 'If/Else Node docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      a2aProtocol: {
+        value:
+          'No: no public StackAI documentation, changelog, or blog post mentions support for the Agent2Agent (A2A) protocol or Agent Cards.',
+        detail:
+          'StackAI documents MCP-style tool integration and Subflow Tools/StackAI Project nodes for composing agents, but nothing referencing the A2A open standard was found as of this check.',
+        shortValue: 'Not documented',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.stackai.com',
+            label: 'StackAI documentation',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    integrations: {
+      integrationCount: {
+        value: '100+ enterprise integrations',
+        detail:
+          'Includes Notion, Airtable, AWS, BigQuery, GitHub, Google Workspace, HubSpot, MongoDB, and MCP.',
+        shortValue: '100+ integrations',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.stackai.com/integrations',
+            label: 'StackAI Integrations page',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      triggerTypes: {
+        value:
+          'Scheduled/time-based triggers and outbound webhook calls (e.g., to Make); no native inbound webhook trigger node',
+        detail:
+          'Supports scheduled workflows (daily/weekly/monthly automation) and a Make node that can POST to trigger a Make.com scenario. Deployment surfaces include chat, forms, API, Slack, Teams, and batch run.',
+        shortValue: 'Scheduled triggers, outbound webhooks only',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.stackai.com/insights/how-to-set-up-scheduled-ai-workflows-and-automated-reports-on-stackai',
+            label: 'Scheduled AI Workflows - StackAI insights',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.stackai.com/workflow-builder/apps/make',
+            label: 'Make node - StackAI Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      customCodeSteps: {
+        value: 'Yes: Python code node',
+        detail: 'A dedicated Python Code node allows custom logic within workflows.',
+        shortValue: 'Python code node',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/logic/python-code',
+            label: 'Python Code - StackAI Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      apiPublishing: {
+        value: 'Yes: workflows publishable as a REST API with generated client snippets',
+        detail:
+          'Any flow can be exported and published as an API. Docs provide request snippets in Python, JavaScript, and cURL, with OAuth2-token authentication and a separate API reference.',
+        shortValue: 'Publish workflows as REST APIs',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/export-options/api',
+            label: 'API - StackAI Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      extensibilitySdk: {
+        value:
+          'Client code snippets only (Python, JavaScript, cURL); no installable SDK package, plugin/custom-node dev kit, or community integration marketplace',
+        detail:
+          "Docs provide request snippets for calling a published flow's API, but there's no distributable SDK package, documented custom-node/plugin SDK, or marketplace of community-built integrations.",
+        shortValue: 'Code snippets only, no SDK or marketplace',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/export-options/api',
+            label: 'API - StackAI Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      mcpPublishing: {
+        value:
+          'Yes: StackAI provides a hosted MCP server (mcp.stack.ai/mcp) and an open-source stack-ai-mcp server. Either lets external MCP-compatible clients, such as Claude Desktop, run a published StackAI workflow as a callable MCP tool, passing inputs in and getting structured results back.',
+        shortValue: 'Yes, publishes workflows as MCP servers',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/workflow-builder/apps/mcp',
+            label: 'MCP node docs',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.stackai.com/blog/how-to-use-the-stack-ai-mcp-server',
+            label: 'How to Use the Stack AI MCP Server',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    pricing: {
+      pricingModel: {
+        value: 'Freemium + custom-quote Enterprise tier, metered by monthly runs/projects/seats',
+        shortValue: 'Freemium plus custom Enterprise quote',
+        confidence: 'verified',
+        sources: [
+          { url: 'https://www.stackai.com/pricing', label: 'StackAI Pricing', asOf: '2026-07-02' },
+        ],
+      },
+      entryPaidPlan: {
+        value: 'No self-serve paid tier. Only Free and custom-quote Enterprise',
+        detail:
+          'The pricing page shows only "Free" ($0/mo) and "Enterprise" (custom pricing); there is no self-serve paid mid-tier.',
+        shortValue: 'No mid-tier, Enterprise is quote-only',
+        confidence: 'verified',
+        sources: [
+          { url: 'https://www.stackai.com/pricing', label: 'StackAI Pricing', asOf: '2026-07-02' },
+        ],
+      },
+      freeTier: {
+        value: 'Yes: 500 runs/month, 2 projects, 1 seat, community Discord support',
+        shortValue: '500 runs/mo, 2 projects, 1 seat',
+        confidence: 'verified',
+        sources: [
+          { url: 'https://www.stackai.com/pricing', label: 'StackAI Pricing', asOf: '2026-07-02' },
+        ],
+      },
+      byok: {
+        value: 'Unknown',
+        shortValue: 'Not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+    },
+    security: {
+      soc2: {
+        value: 'Yes: SOC 2 Type II, audited by Modern Assurance',
+        shortValue: 'SOC 2 Type II certified',
+        confidence: 'verified',
+        sources: [
+          { url: 'https://trust.stackai.com/', label: 'StackAI Trust Center', asOf: '2026-07-02' },
+          {
+            url: 'https://www.stackai.com/blog/soc2-type2-hipaa',
+            label: 'StackAI SOC 2 Type II & HIPAA blog',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      dataResidency: {
+        value: 'Unknown',
+        shortValue: 'Not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      rbac: {
+        value:
+          'Access controls and SSO on the Enterprise plan; least-privilege access to customer data internally',
+        detail:
+          'The Enterprise plan includes access control and SSO. The Trust Center states customer-data access is restricted on a least-privilege basis with unique personnel IDs and controlled non-console production access.',
+        shortValue: 'Enterprise SSO plus least-privilege access',
+        confidence: 'verified',
+        sources: [
+          { url: 'https://www.stackai.com/pricing', label: 'StackAI Pricing', asOf: '2026-07-02' },
+          { url: 'https://trust.stackai.com/', label: 'StackAI Trust Center', asOf: '2026-07-02' },
+        ],
+      },
+      auditLogging: {
+        value: 'Yes: automatic logs of every run, capturing input/output, token usage, and runtime',
+        shortValue: 'Automatic per-run execution logs',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/welcome-to-stackai/overview/platform-overview',
+            label: 'StackAI Platform Overview docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      additionalCompliance: {
+        value:
+          'ISO 27001 certified. StackAI was also audited against HIPAA in the same review cycle as its SOC 2 Type II audit, though the public Trust Center page itself lists only SOC 2 and ISO 27001, not HIPAA',
+        detail:
+          'The Trust Center confirms SOC 2 Type II and ISO 27001, DPAs with OpenAI and Anthropic, and a May 2025 penetration test with a Low risk rating. A separate StackAI blog post states the company "was also audited against HIPAA standards during the same period as the SOC 2 Type II audit." GDPR compliance is referenced on the Enterprise pricing page but was not independently confirmed via a dedicated audit source.',
+        shortValue: 'ISO 27001 certified; HIPAA audited, GDPR marketing-only',
+        confidence: 'estimated',
+        sources: [
+          { url: 'https://trust.stackai.com/', label: 'StackAI Trust Center', asOf: '2026-07-02' },
+          {
+            url: 'https://www.stackai.com/blog/soc2-type2-hipaa',
+            label: 'StackAI SOC 2 Type II & HIPAA blog',
+            asOf: '2026-07-02',
+          },
+          { url: 'https://www.stackai.com/pricing', label: 'StackAI Pricing', asOf: '2026-07-02' },
+        ],
+      },
+      modelAndToolGovernance: {
+        value: 'Unknown',
+        shortValue: 'Not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      credentialGovernance: {
+        value:
+          'Yes: owners and admins can share a connection org-wide or restrict it to specific users or groups, separately from the four-tier role system (Admin, Editor, User, Viewer). StackAI recommends pairing private folders with restricted connections and knowledge bases for sensitive workflows.',
+        shortValue: 'Yes, per-connection user/group restriction',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/governance-and-security/workspace-and-folder-access',
+            label: 'Workspace and Folder Access docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      whiteLabeling: {
+        value:
+          'Unknown: no public documentation was found confirming that StackAI lets customers replace its logo/product name/theme colors across the workspace or deployed-app UI. Deployed chat interfaces can be styled/branded, but full workspace-level white-labeling was not confirmed.',
+        detail:
+          "Marketing pages reference brand guidelines for StackAI's own brand, and chat widgets can be styled to match a customer's site, but no source confirms full white-label replacement of vendor branding.",
+        shortValue: 'Unknown, not publicly documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      dataRetention: {
+        value:
+          "Yes: StackAI's Trust Center and security documentation state the org can configure data retention durations, backed by a documented Data Retention and Disposal Policy, rather than a single fixed platform-wide default.",
+        detail:
+          'Public sources describe the policy existing and retention being settable, but exact granularity (per-resource-type controls like execution logs vs soft-deleted items separately) was not independently confirmed.',
+        shortValue: 'Yes, configurable retention windows',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://trust.stackai.com/',
+            label: 'StackAI Trust Center',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.stackai.com/security-and-privacy',
+            label: 'Security & Privacy docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      piiRedaction: {
+        value:
+          "Yes: StackAI's security page states that built-in mechanisms detect and mask personally identifiable information (PII) during processing. Its guardrails guidance also covers redacting PII in inputs, retrieval, and logs as part of enterprise agent design.",
+        shortValue: 'Yes, built-in PII detection/masking',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://www.stackai.com/security',
+            label: 'StackAI Security page',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.stackai.com/insights/how-to-design-ai-agent-guardrails-best-practices-for-input-validation-output-filtering-and-safety-controls',
+            label: 'AI Agent Guardrails guide',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      sso: {
+        value:
+          'Yes: StackAI supports Single Sign-On through a dedicated SSO settings page, integrating with identity providers like Okta and Entra ID to inherit groups and permissions. Newly provisioned SSO users get a default role, and admins can require SSO for all interfaces org-wide.',
+        detail:
+          "Docs confirm SSO login and default-role auto-provisioning behavior; the specific SAML vs OIDC protocol labeling was not directly quotable from a live doc page (one target page 404'd), so protocol details are inferred from the Okta/Entra ID integration claim.",
+        shortValue: 'Yes, SSO with Okta/Entra ID',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.stackai.com/sso',
+            label: 'StackAI SSO login page',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.stackai.com/insights/sso-and-rbac-for-ai-agents-how-to-secure-enterprise-ai-deployments',
+            label: 'SSO and RBAC for AI Agents',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    observability: {
+      tracingDepth: {
+        value:
+          'Analytics dashboard with usage graphs and per-run execution logs; no dedicated span-level distributed tracing UI',
+        detail:
+          'An Analytics section shows workflow usage graphs and a full list of execution logs (input/output, token usage, runtime performance). There is no granular per-step span tracing for individual tool-call/LLM-call spans within a run.',
+        shortValue: 'Usage dashboard and run logs, no span tracing',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/welcome-to-stackai/overview/platform-overview',
+            label: 'StackAI Platform Overview docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      durabilityModel: {
+        value: 'Unknown',
+        detail:
+          'No documented automatic retries, checkpointing, or replay of past executions with original inputs.',
+        shortValue: 'Not documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      failureAlerting: {
+        value: 'Unknown',
+        detail:
+          'No documented proactive failure or threshold alerting; only after-the-fact execution logs are available.',
+        shortValue: 'No proactive alerting documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      dataDrains: {
+        value:
+          'Unknown: no public documentation was found describing continuous export of StackAI execution/audit/usage data to an external destination such as S3, BigQuery, Datadog, or a generic webhook sink. Only per-run API access and project export/import were documented.',
+        detail:
+          'Docs cover an API export view (calling a flow via POST) and project export/import, which are pull/one-shot mechanisms, not a continuous log-drain feature.',
+        shortValue: 'Unknown, not publicly documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      asyncExecution: {
+        value:
+          "Partial: StackAI's Analytics API can list and filter runs by ID and by status (including pending, paused, resumed, completed, failed, and cancelled) after the fact, which supports a trigger-then-check-later pattern. But StackAI's docs don't describe an official async-trigger-plus-poll workflow for actually running a flow, the way some platforms document a job-queue API.",
+        detail:
+          "The API used to run a flow only documents a request/response call that waits for the result, with no explicit async job or webhook pattern. The separate Analytics API does expose a run ID and status field, including a pending state, that can be queried after submission. That's evidence a run's status can be checked later, but it's inferred from the analytics endpoint rather than a documented async execution feature.",
+        shortValue: 'Partial: run status queryable later, no documented async API',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/interface-and-deployment/api-reference/run-flow.md',
+            label: 'StackAI API Reference: Run Flow',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.stackai.com/interface-and-deployment/api-reference/analytics.md',
+            label: 'StackAI API Reference: Analytics (run state/run_id)',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      executionLimits: {
+        value:
+          'Partial: the only concrete published number is a usage quota, not a timeout or concurrency limit. The Free plan caps usage at 500 runs per month (2 projects, 1 seat), while Enterprise plans get custom or unlimited run allowances. No public documentation states a maximum single-execution duration or a cap on concurrent executions.',
+        detail:
+          "Checked the official pricing page and the API reference pages; none disclose a per-request timeout or a concurrent-execution cap. This is a gap in StackAI's public documentation, not a confirmed absence of limits.",
+        shortValue: '500 runs/month on Free tier; no published timeout/concurrency',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.stackai.com/pricing',
+            label: 'StackAI Pricing (500 runs/month on Free plan)',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.stackai.com/interface-and-deployment/api-reference.md',
+            label: 'StackAI API Reference index (no rate/timeout limits listed)',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      partialFailureHandling: {
+        value:
+          "Yes: each node can have a 'Fallback Branch' (On Error) that, when enabled, lets the workflow keep going after that node fails instead of halting the whole run. It routes execution to an alternate path, such as returning a safe message, emitting a structured error, or notifying a human.",
+        detail:
+          "StackAI's documentation also describes a complementary 'Retry on Failure' setting (configurable max retries and retry interval) and an LLM Fallback Mode, and recommends layering them: retries first, then an LLM fallback, then the fallback branch.",
+        shortValue: 'Yes, via node-level Fallback Branch / On Error',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/guides-and-tips/stackai-hacks/handling-errors-and-fallback.md',
+            label: 'StackAI: Handling Errors & Fallback (Fallback Branch, Retry on Failure)',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    support: {
+      supportChannels: {
+        value:
+          'Community Discord (free tier); dedicated solution engineers / forward-deployed engineers (Enterprise)',
+        shortValue: 'Discord free, dedicated engineers on Enterprise',
+        confidence: 'verified',
+        sources: [
+          { url: 'https://www.stackai.com/pricing', label: 'StackAI Pricing', asOf: '2026-07-02' },
+        ],
+      },
+      sla: {
+        value: 'Enterprise plans include support SLAs; exact terms are not publicly documented',
+        shortValue: 'Enterprise SLAs, terms undisclosed',
+        confidence: 'estimated',
+        sources: [],
+      },
+      community: {
+        value:
+          'Discord community, comprehensive docs, and a StackAI Academy with tutorials and courses',
+        shortValue: 'Discord, docs, and StackAI Academy',
+        confidence: 'verified',
+        sources: [
+          { url: 'https://www.stackai.com/academy', label: 'StackAI Academy', asOf: '2026-07-02' },
+        ],
+      },
+      companyMaturity: {
+        value:
+          'Acquired by Asana in a deal worth approximately $75 million, announced May 28, 2026. StackAI is now a subsidiary of Asana rather than an independent company',
+        detail:
+          'Founders Antoni Rosinol and Bernardo Aceituno joined Asana as part of the acquisition. Prior to the acquisition, StackAI had raised just under $20M total: a ~$3M seed round in 2023 led by Gradient Ventures (with Y Combinator, Soma Capital, and others participating), and a $16M Series A in May 2025 led by Lobby Capital and LifeX Ventures, with Gradient Ventures and Epakon Capital returning.',
+        shortValue: 'Now a subsidiary of Asana (acquired 2026)',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://techcrunch.com/2026/05/28/asana-acquires-no-code-agent-builder-stack-ai/',
+            label: 'Asana acquires StackAI - TechCrunch',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.stackai.com/blog/stack-ai-raises-16m-series-a-to-create-ai-agents-for-every-job',
+            label: 'StackAI Raises $16M Series A - StackAI blog',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.ycombinator.com/companies/stackai',
+            label: 'StackAI - Y Combinator company page',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      academy: {
+        value:
+          'Yes: StackAI runs a structured StackAI Academy with step-by-step lessons and courses covering platform overview, building workflows, knowledge bases, and agent building, plus a separate enterprise offering for AI-driven skills testing and certification.',
+        detail:
+          'Academy is lesson-based (multiple numbered courses); certification is offered as a distinct enterprise solution (skills testing and certification), not confirmed to be bundled into the core Academy itself.',
+        shortValue: 'Yes, has StackAI Academy courses',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.stackai.com/getting-started/learning/stackai-academy',
+            label: 'StackAI Academy docs',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.stackai.com/academy',
+            label: 'StackAI Academy',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.stackai.com/solutions/skills-testing-and-certification',
+            label: 'Skills Testing and Certification',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+  },
+}

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

@@ -0,0 +1,991 @@
+import { VellumIcon } 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 vellumProfile: CompetitorProfile = {
+  id: 'vellum',
+  name: 'Vellum',
+  website: 'https://www.vellum.ai',
+  isWorkflowBuilder: false,
+  brand: {
+    icon: VellumIcon,
+    selfFramed: true,
+    colors: ['#5c54dd', '#aca4ec', '#442c6c'],
+    source: 'Context.dev brand-intelligence API',
+    asOf: '2026-07-02',
+  },
+  oneLiner:
+    'Vellum is an enterprise AI development platform for building, evaluating, and deploying LLM prompts, workflows, and agents.',
+  standoutFeatures: [
+    {
+      title: 'Self-hosted / VPC enterprise deployment',
+      description:
+        "Enterprise customers can run the platform inside their own AWS, Azure, or GCP VPC (or on-prem) via a Replicated-based install, keeping prompts and documents inside the customer's network perimeter.",
+      shortDescription: 'Runs inside your own AWS/Azure/GCP VPC or on-prem.',
+      source: {
+        url: 'https://docs.vellum.ai/self-hosting/getting-started/introduction',
+        label: 'Self-Hosted Vellum: Vellum Docs',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: "Natural-language agent building ('Vellum for Agents')",
+      description:
+        'Non-technical users can describe a goal in plain language and have Vellum generate a working agent, automatically handling model selection, prompting, and integration wiring.',
+      shortDescription: 'Describe a goal in plain language and Vellum builds the agent.',
+      source: {
+        url: 'https://www.vellum.ai/blog/introducing-vellum-for-agents',
+        label: 'Introducing Vellum for Agents',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'SOC 2 Type 2 and HIPAA compliance with BAA',
+      description:
+        'Vellum documents SOC 2 Type 2 attestation and HIPAA compliance, with enterprise customers able to sign a Business Associate Agreement for handling protected health information, corroborated by a third-party Drata case study.',
+      shortDescription: 'SOC 2 Type 2 and HIPAA compliance with a signable BAA.',
+      source: {
+        url: 'https://drata.com/customers/vellum',
+        label: 'Vellum Case Study: Drata',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: '$20M Series A, followed by a consumer pivot',
+      description:
+        "Vellum raised a $20M Series A in July 2025 (on top of a 2023 YC seed) to grow its enterprise platform. Since then, the company has separately launched a rebranded 'Personal Intelligence' consumer assistant product, open-sourced under MIT license on GitHub.",
+      shortDescription: '$20M Series A, then a separate consumer product launch.',
+      source: {
+        url: 'https://www.vellum.ai/blog/announcing-our-20m-series-a',
+        label: 'Announcing our $20m Series A: Vellum',
+        asOf: '2026-07-02',
+      },
+    },
+  ],
+  limitations: [
+    {
+      title: 'Brand/product ambiguity as of mid-2026',
+      description:
+        "Vellum's homepage, pricing page, security docs, and several product pages now serve content for a new consumer 'Personal Intelligence' assistant (an open-source, MIT-licensed Mac app) rather than the original enterprise workflow, evaluations, and prompt-engineering platform. That makes current enterprise-specific details, like environment promotion, version-control depth, tracing, alerting, and integration counts, harder to verify from the public site alone.",
+      shortDescription:
+        'Public site now foregrounds a consumer product over the enterprise platform.',
+      source: {
+        url: 'https://www.vellum.ai/',
+        label: 'Vellum: Your Personal Intelligence',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'BYOK not documented on pricing',
+      description:
+        "Vellum's pricing pages describe a prepaid-credit model where Vellum passes through LLM costs at cost, with no bring-your-own-API-key option mentioned as an alternative billing or configuration path.",
+      shortDescription: 'No bring-your-own-key option mentioned on pricing pages.',
+      source: { url: 'https://www.vellum.ai/pricing', label: 'Vellum Pricing', asOf: '2026-07-02' },
+    },
+    {
+      title: 'No enterprise SLA published',
+      description:
+        'No uptime or response-time SLA commitments are published on the enterprise or pricing pages.',
+      shortDescription: 'No public SLA commitments found.',
+      source: {
+        url: 'https://www.vellum.ai/enterprise',
+        label: 'Vellum Enterprise',
+        asOf: '2026-07-02',
+      },
+    },
+    {
+      title: 'Deprecated legacy workflow nodes',
+      description:
+        'As of the January 2026 changelog, Vellum deprecated Merge, Conditional, and Output Nodes from the workflow builder UI (replaced by Merge Strategy, Ports, and Workflow Outputs respectively). Existing workflows using them continue to run but new instances can no longer be created.',
+      shortDescription:
+        'Legacy Merge/Conditional/Output nodes retired in favor of newer equivalents.',
+      source: {
+        url: 'https://docs.vellum.ai/changelog/2026/2026-01',
+        label: 'Vellum Changelog: January 2026',
+        asOf: '2026-07-02',
+      },
+    },
+  ],
+  facts: {
+    platform: {
+      builderType: {
+        value:
+          "Visual workflow builder plus a code-first SDK, and a natural-language 'Vellum for Agents' mode for non-technical users",
+        detail:
+          "Vellum offers a visual graph builder and a code-first SDK that stay in sync, with nodes for model calls, retrieval, tool/API steps, and control flow. A separate 'Vellum for Agents' surface lets non-engineers describe a goal in plain language to generate an agent.",
+        shortValue: 'Visual builder, code SDK, or natural language',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.vellum.ai/blog/introducing-vellum-for-agents',
+            label: 'Introducing Vellum for Agents',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://skywork.ai/blog/vellum-ai-review-prompt-management-evaluations-orchestration/',
+            label: 'Vellum AI Review: Prompt Management, Evaluations & Orchestration',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      learningCurve: {
+        value: 'Unknown',
+        detail: 'Not publicly documented.',
+        shortValue: 'Not publicly documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      selfHostOption: {
+        value: 'Yes: self-hosted / VPC install available for enterprise customers',
+        detail:
+          "A 'Self-Hosted Vellum' path and a VPC Install option (via a Replicated-based deployment) let enterprises run the platform in their own AWS/Azure/GCP VPC or on-prem.",
+        shortValue: 'Self-hosted / VPC for enterprise',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/self-hosting/getting-started/introduction',
+            label: 'Self-Hosted Vellum: Vellum Docs',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.vellum.ai/blog/announcing-vellum-vpc',
+            label: 'Announcing Vellum VPC',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      deploymentOptions: {
+        value: 'Vellum Cloud (SaaS), self-hosted, and VPC install on AWS/Azure/GCP or on-prem',
+        shortValue: 'Cloud, self-hosted, or VPC install',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/self-hosting/getting-started/introduction',
+            label: 'Self-Hosted Vellum: Vellum Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      templates: {
+        value:
+          'A templates page exists on vellum.ai, though its contents are not publicly detailed.',
+        shortValue: 'Exists; contents undocumented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      license: {
+        value:
+          "Proprietary/commercial for the core enterprise Vellum platform. A separate consumer 'Vellum Assistant' product is open-sourced under MIT license.",
+        detail:
+          'github.com/vellum-ai/vellum-assistant is MIT-licensed (confirmed live, 825+ stars). No evidence the enterprise workflow/evaluations platform itself is open source.',
+        shortValue: 'Proprietary enterprise platform; MIT consumer app',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://github.com/vellum-ai/vellum-assistant',
+            label: 'vellum-ai/vellum-assistant: GitHub',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      environmentPromotion: {
+        value:
+          "Vellum has Development/Staging/Production environments, each with isolated API keys, Release histories, and environment variables/secrets. Promotion works via a 'Promote' button on a Release to move a tested version to another environment, or by deploying directly to multiple environments at once. Sandboxes (prompt/workflow definitions) are shared across environments. Deployments and releases are environment-scoped.",
+        detail:
+          'Promotion operates at the level of individual workflow/prompt releases rather than whole-workspace forking.',
+        shortValue: 'Dev/Staging/Prod with one-click promotion',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/deployments/environments',
+            label: 'Vellum Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      versionControlDepth: {
+        value:
+          'Vellum maintains per-environment Release history with instant one-click rollback (no code changes required) and supports semantic-versioned Release Tags or a rolling LATEST tag. Version comparison is mentioned, but a dedicated diff/side-by-side comparison view is not explicitly documented.',
+        shortValue: 'Release history with one-click rollback',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://skywork.ai/blog/vellum-ai-review-prompt-management-evaluations-orchestration/',
+            label: 'Vellum AI Review: Prompt Management, Evaluations & Orchestration',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.vellum.ai/product/deployments/deployment-lifecycle-management',
+            label: 'Vellum Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      realtimeCollaboration: {
+        value:
+          "No: Vellum's collaboration model is asynchronous, not live multi-user editing. Prompt Sandbox lets team members see each other's history, tag entries, and share/invite others, but there is no documented live-cursor or simultaneous editing of the same workflow or prompt.",
+        detail:
+          'Vellum documentation describes shared visibility into sandbox history and sharing/invite mechanisms, explicitly framed around sequential iteration rather than simultaneous editing.',
+        shortValue: 'Async collaboration, no live co-editing',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/prompts/collaboration',
+            label: 'Collaborate on Prompts with Vellum Prompt Sandbox',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      nativeFileStorage: {
+        value:
+          "No: Vellum's document handling is scoped to Document Indexes for RAG (upload, indexing, search), not a general-purpose file storage system. No documentation of folder hierarchy, shareable links with password/SSO auth, or a trash/recovery feature was found.",
+        detail:
+          "Documents are described as 'Environment-scoped', uploaded for indexing with size limits (e.g. up to 32MB) and supported formats (PDF, DOCX, CSV, etc.), but folder hierarchy, link-sharing with auth, and deleted-item recovery are not documented.",
+        shortValue: 'RAG document indexes only, not general file storage',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/documents/uploading-documents',
+            label: 'Easy Guide to Uploading Documents on Vellum AI',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      dataTables: {
+        value:
+          "No: no evidence of a native spreadsheet-like data table feature (with row/column limits and spreadsheet keyboard navigation) as a standalone platform primitive. Vellum's tabular-data handling is limited to processing uploaded CSV/XLS files and extracting or generating structured output within workflow nodes.",
+        detail:
+          'Vellum documents document upload support for CSV/XLS and structured JSON extraction, and blog content about converting PDFs to CSV, but not an editable in-platform spreadsheet/data-table object comparable to a native DB feature.',
+        shortValue: 'No native spreadsheet-style data table feature',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/developers/workflows-sdk/tutorials/document-data-extraction',
+            label: 'Document Data Extraction - Vellum Documentation',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.vellum.ai/blog/tutorial-how-to-convert-any-pdf-to-csv',
+            label: 'Tutorial: How to Convert Any PDF to CSV - Vellum',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      richTextEditor: {
+        value:
+          'Unknown: no documentation was found describing an inline rich-text/WYSIWYG markdown editor for documents stored within the B2B Vellum workflow platform (docs.vellum.ai). Prompt/node inputs in Workflows appear to be plain text/code fields.',
+        detail:
+          'A rich-text/Markdown document editor is documented for the separate, distinct Vellum personal-assistant product (vellum.ai, a 2026 pivot product), not confirmed for the B2B workflow/agent development platform being compared to Sim.',
+        shortValue: 'Unknown for the workflow platform',
+        confidence: 'unknown',
+        sources: [],
+      },
+    },
+    aiCapabilities: {
+      multiLlmSupport: {
+        value:
+          'Model-agnostic across 20-23+ providers (OpenAI, Anthropic, Google/Gemini, Cohere, Azure OpenAI, Bedrock, Fireworks, Perplexity, Cerebras, Groq, etc.) and hundreds of individual models, including recent additions like GPT-5 and Claude Opus 4.1.',
+        shortValue: '20+ providers, hundreds of models',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/changelog/2025/2025-08',
+            label: 'Vellum Changelog',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      agentReasoningBlocks: {
+        value:
+          "Vellum has a documented 'Agent Node' (formerly 'Tool Calling Node') as its dedicated agent/reasoning-and-tool-execution block type within Workflows, supporting raw code, subworkflows, MCP tools, and Composio SaaS actions side by side in one node.",
+        shortValue: 'Agent Node handles reasoning + tool execution',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/workflows/nodes/agent-node',
+            label: 'Vellum Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      naturalLanguageBuilding: {
+        value:
+          "Yes: 'Vellum for Agents' lets users describe a goal in plain language to generate a working agent",
+        detail:
+          'Handles model selection, prompt engineering, and integration wiring automatically from a natural-language description; targeted at Ops/Finance/Sales/Marketing users.',
+        shortValue: 'Describe a goal, get a working agent',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.vellum.ai/blog/introducing-vellum-for-agents',
+            label: 'Introducing Vellum for Agents',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      knowledgeBaseRag: {
+        value:
+          "Vellum supports RAG via 'Document Indexes' and a dedicated 'Evaluating RAG Pipelines' documentation area.",
+        shortValue: 'Document Indexes + RAG pipeline evaluation',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/evaluation/evaluating-rag-pipelines',
+            label: 'Vellum Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      mcpSupport: {
+        value:
+          "Agent Nodes support adding a remote MCP server as a tool via a '+ Tool' button, with automatic tool discovery (since August 2025).",
+        shortValue: 'Remote MCP servers with auto tool discovery',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/changelog/2025/2025-08',
+            label: 'Vellum Changelog',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      evaluationGuardrails: {
+        value:
+          "Vellum's 'Evaluations' product uses Test Suites and Metrics (0-1 scores) for quantitative evaluation, supports bulk CSV test-case upload, online/production evaluations, custom reusable metrics, and RAG-pipeline evaluation.",
+        shortValue: 'Test suites, scored metrics, production evals',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://skywork.ai/blog/vellum-ai-review-prompt-management-evaluations-orchestration/',
+            label: 'Vellum AI Review: Prompt Management, Evaluations & Orchestration',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.vellum.ai/product/evaluation/quantitative-evaluation',
+            label: 'Vellum Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      humanInTheLoop: {
+        value:
+          "An 'External Input' node pauses Workflow execution until a human or external system supplies input, enabling human-in-the-loop approval patterns.",
+        shortValue: 'External Input node for approvals',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://github.com/vellum-ai/vellum-python-sdks/blob/main/src/vellum/workflows/README.md',
+            label: 'GitHub',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      generativeMedia: {
+        value: 'Unknown',
+        detail:
+          'Pricing includes credits for image generation as a billable usage type, but specific image/video/audio blocks or supported providers are not publicly detailed.',
+        shortValue: 'Image-gen credits exist; blocks undocumented',
+        confidence: 'unknown',
+        sources: [
+          { url: 'https://www.vellum.ai/pricing', label: 'Vellum Pricing', asOf: '2026-07-02' },
+        ],
+      },
+      dynamicToolUse: {
+        value: 'Unknown',
+        detail: 'Not publicly documented.',
+        shortValue: 'Not publicly documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      modelFallback: {
+        value: 'Unknown',
+        detail: 'Not publicly documented.',
+        shortValue: 'Not publicly documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      agentSkills: {
+        value:
+          "No: no evidence found of a named, reusable prompt or knowledge-snippet feature invoked by reference across multiple agents. Vellum's reuse primitives are Subworkflows (reusable workflow logic blocks) and shared Prompt Sandboxes, not a discrete 'skill' object referenced by name across agents.",
+        detail:
+          "Reuse is achieved via Subflows/subworkflows and deployed prompts, which is a different mechanism than a discrete named prompt-snippet library referenced across agents. Note: the separate Vellum personal-assistant product (a distinct pivot product) does have a 'Skills' concept, but that is not documented as part of the B2B workflow platform being compared here.",
+        shortValue: 'Only subworkflows, no named skill objects',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/workflows/common-architectures',
+            label: 'Building Common LLM Architectures with Vellum Workflows',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.vellum.ai/blog/built-in-tool-calling-for-complex-agent-workflows',
+            label: 'Built-In Tool Calling for Complex Agent Workflows',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      nativeChatDeployment: {
+        value:
+          'Yes: Vellum Agents can be built with a first-class Chat Message Trigger that maintains chat_history/conversation state across turns, and Workflows/Agents can be deployed with this chat interaction pattern rather than only form/API/webhook targets.',
+        detail:
+          "Documented alongside RAG chatbot tutorials and the Agent Node's conversation-state handling; deployment surface details (e.g., a hosted public chat widget URL) were not independently confirmed beyond the trigger/state mechanism.",
+        shortValue: 'Chat Message Trigger for deployed conversational agents',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/workflows/tutorials/building-a-rag-chatbot',
+            label: 'Building a RAG Chatbot from Scratch - Vellum Documentation',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.vellum.ai/changelog/2026/2026-01',
+            label: 'Vellum Changelog: January 2026',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      kbChunkVisibility: {
+        value:
+          "Yes: Vellum's Document Index search returns individual chunk-level results, and Advanced Chunking exposes per-chunk metadata (like the source page range) alongside configurable chunk size and overlap settings, giving chunk-level visibility for debugging retrieval quality.",
+        detail:
+          'Documented under the Document Indexes / Search API and RAG pipeline evaluation docs; each search result object represents one matching chunk, not a whole document.',
+        shortValue: 'Search returns per-chunk results with metadata',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/developers/client-sdk/document-indexes/search',
+            label: 'Search - Vellum Documentation',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.vellum.ai/product/evaluation/evaluating-rag-pipelines',
+            label: 'Evaluating RAG Pipelines - Vellum Documentation',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      parallelExecution: {
+        value:
+          'Yes: Vellum Workflows has a Map Node that iterates over an array and executes a subworkflow concurrently for each item, and a Merge Strategy (available on all node types, replacing the older standalone Merge Node) that consolidates divergent execution paths back into one result.',
+        detail:
+          'As of the January 2026 release, the standalone Merge Node was replaced by Merge Strategy, a setting on every node type, so branches can fan out via the Map Node and fan back in without a dedicated join node.',
+        shortValue: 'Map Node fans out, Merge Strategy fans back in',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/developers/workflows-sdk/api-reference/nodes/merge-node',
+            label: 'Merge Node - Vellum Documentation',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.vellum.ai/changelog/2026/2026-01',
+            label: 'Vellum Changelog: January 2026',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      a2aProtocol: {
+        value:
+          'No: Vellum documentation and changelogs show no support for the Agent2Agent (A2A) protocol. Vellum has written about the related Google AP2 payments protocol, but has not documented an A2A implementation or Agent Card support.',
+        detail:
+          'No mentions of "Agent2Agent" or "A2A" appear in Vellum product docs, help center, or changelog as of this review; this reflects the absence of public documentation, not a confirmed statement from Vellum that it will never support it.',
+        shortValue: 'Not documented',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/',
+            label: 'Vellum Documentation (no A2A/Agent2Agent results)',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.vellum.ai/blog/googles-ap2-a-new-protocol-for-ai-agent-payments',
+            label: "Google's AP2: A new protocol for AI agent payments - Vellum Blog",
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    integrations: {
+      integrationCount: {
+        value:
+          "Via a Composio partnership (August 2025), Vellum connects to Composio's library of 10,000+ tools directly inside Agent Nodes (Google Sheets, Slack, Salesforce, Notion, Jira, Linear, Trello, etc.). Vellum separately advertises 100+ of its own native integrations.",
+        shortValue: '10,000+ tools via Composio, 100+ native',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://www.vellum.ai/blog/introducing-vellum-for-agents',
+            label: 'Introducing Vellum for Agents',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.vellum.ai/blog/vellum-composio-new-partnership-for-ai-agent-building',
+            label: 'Vellum Blog',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      triggerTypes: {
+        value: 'Unknown',
+        detail:
+          "A 'Chat Message Trigger' exists for chat-first agent building; the full set of trigger types (webhook, API, etc.) is not publicly enumerated.",
+        shortValue: 'Chat trigger confirmed; full list undocumented',
+        confidence: 'unknown',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/changelog/2026/2026-01',
+            label: 'Vellum Changelog: January 2026',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      customCodeSteps: {
+        value:
+          "Vellum has a documented 'Code Execution Node' supporting custom Python or TypeScript code with a required main() function signature, an in-browser IDE, and support for public PyPI/npm packages. Newer 'Custom Nodes' are expected to eventually replace it.",
+        shortValue: 'Python/TypeScript code node with in-browser IDE',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/workflows/nodes/code-execution-node',
+            label: 'Vellum Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      apiPublishing: {
+        value:
+          'Deploying a Workflow from the Vellum UI produces a code snippet to call it in production as an API. Vellum handles execution server-side and callers just supply input variables; each execution is also viewable/shareable via an execution URL.',
+        shortValue: 'One-click deploy to a callable API',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/workflows/api-integration',
+            label: 'Vellum Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      extensibilitySdk: {
+        value:
+          "The Workflows SDK (GitHub: vellum-ai/vellum-python-sdks) is an open-source Python framework for defining and executing agentic workflows as graphs declaratively; docs also describe a 'Custom Nodes' extensibility tutorial.",
+        detail: 'Language support beyond Python is not publicly confirmed.',
+        shortValue: 'Open-source Python Workflows SDK',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://www.vellum.ai/blog/introducing-vellum-for-agents',
+            label: 'Introducing Vellum for Agents',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.vellum.ai/developers/workflows-sdk/introduction',
+            label: 'Vellum Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      mcpPublishing: {
+        value:
+          "No: Vellum's documented MCP support runs in one direction only. Its Agent Node lets a workflow connect to and call external/remote MCP servers as tools (with auto-discovered schemas). No documentation describes the reverse: publishing a deployed Vellum workflow itself as a callable MCP server for external AI tools to consume.",
+        detail:
+          "August 2025 changelog and blog content describe adding MCP servers as tools inside Agent nodes; a specific 'How does MCP work' Vellum blog post does not address exposing Vellum workflows as MCP endpoints. Some third-party sources conflate this with Vellum's separate personal-assistant product exposing its own MCP server, which is a different, non-workflow-platform product.",
+        shortValue: 'MCP client only, not MCP server publishing',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/changelog/2025/2025-08',
+            label: 'August 2025 Changelog - Vellum Documentation',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.vellum.ai/blog/how-does-mcp-work',
+            label: 'How does MCP work - Vellum Blog',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    pricing: {
+      pricingModel: {
+        value:
+          'Prepaid/pay-as-you-go credits ($1 credit = $1 of underlying LLM/API cost, no markup) plus a tiered monthly subscription for compute/storage',
+        detail:
+          "Current pricing pages describe the consumer 'Personal Intelligence' product's plans (Base/Free and Pro $50/mo tiers with configurable vCPU/RAM/storage add-ons) rather than the original enterprise workflow platform's seat/usage-based pricing.",
+        shortValue: 'Pass-through LLM credits + subscription',
+        confidence: 'verified',
+        sources: [
+          { url: 'https://www.vellum.ai/pricing', label: 'Vellum Pricing', asOf: '2026-07-02' },
+          {
+            url: 'https://www.vellum.ai/docs/pricing',
+            label: 'Vellum Docs: Pricing',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      entryPaidPlan: {
+        value: 'Around $50/month for a typical Pro-tier setup, plus usage credits',
+        detail:
+          "The Pro plan has a $10/month platform fee (includes custom subdomain and priority support). Actual monthly cost depends on the compute tier chosen ($35-$125/mo) and storage tier chosen ($5-$120/mo); Vellum's own example configuration totals $50/month before usage credits.",
+        shortValue: '~$50/mo example configuration plus usage credits',
+        confidence: 'verified',
+        sources: [
+          { url: 'https://www.vellum.ai/pricing', label: 'Vellum Pricing', asOf: '2026-07-02' },
+        ],
+      },
+      freeTier: {
+        value:
+          "Yes: free 'Base' plan with small fixed compute and 4 GiB storage, no credit card required",
+        shortValue: 'Free Base plan, no card required',
+        confidence: 'verified',
+        sources: [
+          { url: 'https://www.vellum.ai/pricing', label: 'Vellum Pricing', asOf: '2026-07-02' },
+        ],
+      },
+      byok: {
+        value: 'Not mentioned on current pricing pages',
+        detail:
+          'Pricing is structured around Vellum-provided credits passed through at cost, with no bring-your-own-API-key option described as an alternative.',
+        shortValue: 'No BYOK option documented',
+        confidence: 'unknown',
+        sources: [
+          { url: 'https://www.vellum.ai/pricing', label: 'Vellum Pricing', asOf: '2026-07-02' },
+        ],
+      },
+    },
+    security: {
+      soc2: {
+        value: 'Yes: SOC 2 Type 2',
+        detail:
+          'Documented at docs.vellum.ai and corroborated by a third-party Drata customer case study noting Vellum achieved SOC 2 Type 1 and Type 2 attestations.',
+        shortValue: 'SOC 2 Type 2 attested',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/security/data-privacy-and-storage',
+            label: 'Vellum Docs: Data Privacy and Storage',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://drata.com/customers/vellum',
+            label: 'Vellum Case Study: Drata',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      dataResidency: {
+        value: 'Unknown: no specific region/residency options documented',
+        detail:
+          "Docs describe data being stored 'in Vellum's infrastructure, isolated in a dedicated, encrypted container' but do not specify selectable data-residency regions.",
+        shortValue: 'No selectable residency regions documented',
+        confidence: 'unknown',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/security/data-privacy-and-storage',
+            label: 'Vellum Docs: Data Privacy and Storage',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      rbac: {
+        value: 'Yes: workspace-level role-based access control with six predefined roles',
+        detail:
+          "Roles are Admin, Deployment Editor, Document Index Editor, Test Suite Editor, Playground Editor, and Member (read-only). Permissions apply workspace-wide rather than per individual resource, and only Admins can change other users' roles.",
+        shortValue: 'Six workspace-level roles, Admin to read-only Member',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/security/rbac-permissions',
+            label: 'Role-Based Access Control (RBAC) - Vellum Documentation',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      auditLogging: {
+        value: 'Unknown',
+        detail:
+          'Not publicly documented for the enterprise platform; permissions-model docs describe per-action risk badges for the consumer assistant product only.',
+        shortValue: 'Not publicly documented',
+        confidence: 'unknown',
+        sources: [
+          {
+            url: 'https://www.vellum.ai/docs/trust-security/the-permissions-model',
+            label: 'Vellum Docs: The Permissions Model',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      additionalCompliance: {
+        value:
+          'HIPAA compliant (BAA available for enterprise customers); ISO 27001, GDPR-specific attestation, PCI, and FedRAMP not confirmed',
+        detail:
+          'Docs and a third-party Drata case study both state Vellum is HIPAA compliant and that enterprise customers can sign a Business Associate Agreement (BAA). No mention of ISO 27001, PCI, or FedRAMP certification was found.',
+        shortValue: 'HIPAA + BAA; no other certs confirmed',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/security/data-privacy-and-storage',
+            label: 'Vellum Docs: Data Privacy and Storage',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://drata.com/customers/vellum',
+            label: 'Vellum Case Study: Drata',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      modelAndToolGovernance: {
+        value: 'Unknown',
+        detail: 'Not publicly documented.',
+        shortValue: 'Not publicly documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      credentialGovernance: {
+        value:
+          'No: Vellum documents workspace-level Role-Based Access Control (Admin/Member style roles governing create/update/delete permissions) but no documentation was found for restricting which specific stored credentials/connections a role or permission group may use.',
+        detail:
+          'RBAC docs describe workspace-wide role permissions (Admin vs Member) rather than credential-level allow/deny lists. A separate, unrelated Vellum personal-assistant product does describe per-credential allowedTools/allowedDomains scoping, but that is a different product from the B2B workflow platform being compared.',
+        shortValue: 'Workspace RBAC only, no per-credential scoping',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/security/rbac-permissions',
+            label: 'Role-Based Access Control (RBAC)',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      whiteLabeling: {
+        value:
+          "Unknown: no documentation was found describing replacing Vellum's own branding (logo, product name, theme) with a customer's branding across the workspace or deployed apps. Only generic 'white glove' Enterprise service language was found, and that refers to onboarding support, not white-label branding.",
+        detail:
+          "Vellum's own branding-guide page addresses Vellum's use of its own brand assets by others, not a customer-facing white-label capability.",
+        shortValue: 'Unknown, no white-label branding docs found',
+        confidence: 'unknown',
+        sources: [],
+      },
+      dataRetention: {
+        value:
+          'Yes: Enterprise customers can configure data retention policies to automatically delete monitoring/interaction data after a specified period (30, 60, 90, or 365 days) instead of the default indefinite retention.',
+        detail:
+          'Configured from Organization Settings under Advanced Settings; default behavior without this Enterprise configuration is indefinite retention.',
+        shortValue: 'Enterprise-configurable 30 to 365 day retention',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/security/data-privacy-and-storage',
+            label: 'Data Privacy and Storage - Vellum Documentation',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      piiRedaction: {
+        value:
+          'Unknown: no documentation was found confirming or denying a dedicated PII detection/redaction feature distinct from generic Guardrail nodes for output validation.',
+        detail:
+          'Vellum documents a general Guardrail Node for workflow quality checks, but no page specifically describing PII detection/redaction (emails, SSNs, etc.) in workflow content or logs was found.',
+        shortValue: 'Unknown',
+        confidence: 'unknown',
+        sources: [],
+      },
+      sso: {
+        value:
+          'Unknown: third-party summaries claim Vellum supports SSO/SAML, but no first-party Vellum documentation describing SAML/OIDC setup or auto-provisioning on first login could be located.',
+        detail:
+          "Vellum's own security/data-privacy documentation page does not mention SSO/SAML, and a direct search of docs.vellum.ai for SSO/SAML configuration returned no dedicated setup page.",
+        shortValue: 'Claimed by third parties, undocumented directly',
+        confidence: 'unknown',
+        sources: [],
+      },
+    },
+    observability: {
+      tracingDepth: {
+        value:
+          'Vellum automatically captures every Prompt/Workflow execution in production into filterable, sortable Executions tables, including per-step inputs, outputs, latency, and aggregated cost, plus shareable execution URLs for linking from external tools and alerts.',
+        shortValue: 'Full execution tracing with shareable URLs',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://skywork.ai/blog/vellum-ai-review/',
+            label: 'Vellum Review: Reliable AI Workflow Orchestration & Observability',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.vellum.ai/product/deployments/observability',
+            label: 'Vellum Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      durabilityModel: {
+        value:
+          "Vellum supports 'Retry Node Adornments' (organized under an 'Error Handling' section of node Settings) that automatically re-invoke a failed node up to a configured max-attempts count.",
+        shortValue: 'Automatic node-level retries',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/workflows/node-types',
+            label: 'Vellum Docs',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      failureAlerting: {
+        value: 'Unknown',
+        detail: 'Not publicly documented.',
+        shortValue: 'Not publicly documented',
+        confidence: 'unknown',
+        sources: [],
+      },
+      dataDrains: {
+        value:
+          'Yes: Vellum supports streaming execution/monitoring events (workflow execution initiated/fulfilled/rejected, usage calculation, metric execution events) continuously to external systems via configurable webhooks, including documented support for forwarding to Datadog.',
+        detail:
+          'Configured from Organization Settings; supports API key, Bearer token, and HMAC verification for webhook payloads. No explicit native S3 or BigQuery connector was found, but the generic webhook mechanism supports building such an export.',
+        shortValue: 'Webhooks stream events to Datadog and custom systems',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/product/monitoring/webhooks',
+            label: 'Webhook Integration - Vellum Documentation',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      asyncExecution: {
+        value:
+          'Yes: Vellum offers an Execute Workflow Async API endpoint that starts a workflow run and returns an execution_id immediately, without blocking. A separate status endpoint lets clients poll for the current state (PENDING, FULFILLED, REJECTED, etc.) and outputs once the run finishes.',
+        detail:
+          'Introduced November 2025. Vellum also documents an Execute Workflow as Stream endpoint for streaming responses, in addition to the synchronous Execute Workflow call that blocks until completion.',
+        shortValue: 'Yes, via async execution_id + status polling',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/changelog/2025/2025-11',
+            label: 'Vellum Changelog, November 2025 (async workflow execution)',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.vellum.ai/developers/client-sdk/workflows/execute-workflow',
+            label: 'Vellum Docs: Execute Workflow (synchronous SDK call)',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.vellum.ai/api-reference/workflows/execute-workflow-stream',
+            label: 'Vellum API Reference: Execute Workflow as Stream',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      executionLimits: {
+        value:
+          'Unknown: Vellum confirms a per-account concurrency limit exists, and that async executions automatically queue once it is exceeded, but does not publish the actual numbers. No max concurrent executions, max execution duration, or requests-per-minute rate limit is listed on its public docs or pricing pages.',
+        detail:
+          "The November 2025 changelog states executions 'automatically queue when you exceed your concurrency limit' but gives no figure. The public pricing page describes credit-based billing and machine sizes (vCPU/RAM tiers) but no execution timeout or concurrency figures. Third-party blog posts cite older per-day execution caps, but these aren't confirmed on Vellum's own current docs, so they aren't included as a verified figure.",
+        shortValue: 'Concurrency limit exists, no public numbers',
+        confidence: 'unknown',
+        sources: [],
+      },
+      partialFailureHandling: {
+        value:
+          "Yes: Vellum lets you wrap any workflow node with a Try or Retry node adornment for first-class error handling, so a single node's failure does not have to halt the entire run. The Try adornment attempts the node once and continues the workflow with an Error output if it fails, while the Retry adornment repeatedly re-invokes the node until it succeeds or a maximum attempt count is reached.",
+        detail:
+          "Adornments are applied from the node's side panel and appear in monitoring as a single-node subworkflow, so downstream branches can consume the Error output and keep the rest of the run going instead of the whole execution stopping.",
+        shortValue: 'Yes, via Try/Retry node adornments',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/changelog/2025/2025-03',
+            label: 'Vellum Changelog, March 2025 (Try/Retry node adornments)',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://docs.vellum.ai/product/workflows/nodes/overview',
+            label: 'Vellum Docs: Nodes Overview (adornments, error handling)',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+    support: {
+      supportChannels: {
+        value: 'Discord community; priority support included on paid plans',
+        detail:
+          'The pricing and enterprise pages reference a Discord community channel and note that the Pro plan includes priority support.',
+        shortValue: 'Discord community + priority support',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.vellum.ai/enterprise',
+            label: 'Vellum Enterprise',
+            asOf: '2026-07-02',
+          },
+          { url: 'https://www.vellum.ai/pricing', label: 'Vellum Pricing', asOf: '2026-07-02' },
+        ],
+      },
+      sla: {
+        value: 'Unknown: no SLA commitments or figures found on current public pages',
+        detail:
+          "The enterprise and pricing pages now serve the consumer 'Personal Intelligence' product and contain no SLA language (uptime, response time, or otherwise). An earlier version of this page may have referenced named SLA features, but that could not be confirmed on the live site, so it is not included as a verified claim.",
+        shortValue: 'No SLA content found on current site',
+        confidence: 'unknown',
+        sources: [],
+      },
+      community: {
+        value: 'Discord community exists',
+        shortValue: 'Discord community',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.vellum.ai/enterprise',
+            label: 'Vellum Enterprise',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      companyMaturity: {
+        value:
+          'Founded 2023 (Y Combinator W23) by Noa Flaherty, Sidd Seethepalli, and Akash Sharma. Raised a $5M seed (2023) and a $20M Series A (July 2025, led by Leaders Fund), for about $25.5M total. Based in New York City, with 150+ reported customers as of the Series A announcement.',
+        shortValue: 'YC W23, ~$25.5M raised, NYC-based',
+        confidence: 'verified',
+        sources: [
+          {
+            url: 'https://www.vellum.ai/blog/announcing-our-20m-series-a',
+            label: 'Announcing our $20m Series A: Vellum',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.crunchbase.com/organization/vellum-74f3',
+            label: 'Vellum: Crunchbase Company Profile & Funding',
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://voicebot.ai/2023/07/13/generative-ai-prompt-engineering-startup-vellum-ai-raises-5m/',
+            label: 'Generative AI Prompt Engineering Startup Vellum.ai Raises $5M: Voicebot.ai',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+      academy: {
+        value:
+          'No: Vellum has not documented a structured Academy-style learning resource with courses or certification. It offers standard documentation (docs.vellum.ai), a blog, and webinars, but no dedicated course/certification program was found.',
+        detail:
+          "Searches for 'Vellum academy', 'certification', 'courses' turned up only docs, blog posts, and webinars; no evidence of a structured curriculum.",
+        shortValue: 'No structured academy or certification',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://docs.vellum.ai/home/getting-started/support',
+            label: "Vellum's Help Center",
+            asOf: '2026-07-02',
+          },
+          {
+            url: 'https://www.vellum.ai/webinars',
+            label: 'Vellum Webinars',
+            asOf: '2026-07-02',
+          },
+        ],
+      },
+    },
+  },
+}

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

@@ -0,0 +1,925 @@
+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://github.com/simstudioai/sim/blob/main/packages/db/schema.ts',
+        label: 'Sim codebase: workspaceForkResourceMap / workspaceForkPromoteRun tables',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/lib/workspaces/fork/promote/promote.ts',
+        label: 'Sim codebase: fork promote engine',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/app/api/workspaces/[id]/fork/route.ts',
+        label: 'Sim codebase: fork creation API',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    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. Org-scoped shared credential sets are preserved verbatim across environments.",
+    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://github.com/simstudioai/sim/blob/main/apps/sim/lib/workspaces/fork/create-fork.ts',
+        label: 'Sim codebase: fork creation (credentials cleared)',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/lib/workspaces/fork/remap/remap-references.ts',
+        label: 'Sim codebase: required-kinds remap/block logic',
+        asOf: '2026-07-02',
+      },
+      {
+        url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/app/api/workspaces/[id]/fork/mapping/route.ts',
+        label: 'Sim codebase: fork credential mapping API',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+  {
+    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://github.com/simstudioai/sim/blob/main/apps/sim/lib/workspaces/fork/lineage/authz.ts',
+        label: 'Sim codebase: assertForkingEnabled / assertCanFork',
+        asOf: '2026-07-02',
+      },
+    ],
+  },
+
+  // ---- 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,27 @@
+export { claudeCoworkProfile } from '@/lib/compare/data/competitors/claude-cowork'
+export { flowiseProfile } from '@/lib/compare/data/competitors/flowise'
+export { gumloopProfile } from '@/lib/compare/data/competitors/gumloop'
+export { langflowProfile } from '@/lib/compare/data/competitors/langflow'
+export { makeProfile } from '@/lib/compare/data/competitors/make'
+export { n8nProfile } from '@/lib/compare/data/competitors/n8n'
+export { openaiAgentkitProfile } from '@/lib/compare/data/competitors/openai-agentkit'
+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,290 @@
+/**
+ * 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
+  }
+  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
+  }
+  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
+  }
+  /**
+   * 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
+  }
+  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))
+}

apps/sim/package.json

@@ -237,6 +237,7 @@
     "@vitejs/plugin-react": "^4.3.4",
     "@vitest/coverage-v8": "^4.1.0",
     "autoprefixer": "10.4.21",
+    "critters": "0.0.25",
     "jsdom": "^26.0.0",
     "postcss": "^8",
     "react-email": "4.3.2",

bun.lock

@@ -305,6 +305,7 @@
         "@vitejs/plugin-react": "^4.3.4",
         "@vitest/coverage-v8": "^4.1.0",
         "autoprefixer": "10.4.21",
+        "critters": "0.0.25",
         "jsdom": "^26.0.0",
         "postcss": "^8",
         "react-email": "4.3.2",
@@ -2243,6 +2244,8 @@
 
     "cpu-features": ["cpu-features@0.0.10", "", { "dependencies": { "buildcheck": "~0.0.6", "nan": "^2.19.0" } }, "sha512-9IkYqtX3YHPCzoVg1Py+o9057a3i0fp7S530UWokCSaFVTc7CwXPRiOjRjBQQ18ZCNafx78YfnG+HALxtVmOGA=="],
 
+    "critters": ["critters@0.0.25", "", { "dependencies": { "chalk": "^4.1.0", "css-select": "^5.1.0", "dom-serializer": "^2.0.0", "domhandler": "^5.0.2", "htmlparser2": "^8.0.2", "postcss": "^8.4.23", "postcss-media-query-parser": "^0.2.3" } }, "sha512-ROF/tjJyyRdM8/6W0VqoN5Ql05xAGnkf5b7f3sTEl1bI5jTQQf8O918RD/V9tEb9pRY/TKcvJekDbJtniHyPtQ=="],
+
     "croner": ["croner@9.1.0", "", {}, "sha512-p9nwwR4qyT5W996vBZhdvBCnMhicY5ytZkR4D1Xj0wuTDEiMnjwR57Q3RXYY/s0EpX6Ay3vgIcfaR+ewGHsi+g=="],
 
     "cronstrue": ["cronstrue@3.3.0", "", { "bin": { "cronstrue": "bin/cli.js" } }, "sha512-iwJytzJph1hosXC09zY8F5ACDJKerr0h3/2mOxg9+5uuFObYlgK0m35uUPk4GCvhHc2abK7NfnR9oMqY0qZFAg=="],
@@ -2735,7 +2738,7 @@
 
     "html-void-elements": ["html-void-elements@3.0.0", "", {}, "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg=="],
 
-    "htmlparser2": ["htmlparser2@10.1.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.2.2", "entities": "^7.0.1" } }, "sha512-VTZkM9GWRAtEpveh7MSF6SjjrpNVNNVJfFup7xTY3UpFtm67foy9HDVXneLtFVt4pMz5kZtgNcvCniNFb1hlEQ=="],
+    "htmlparser2": ["htmlparser2@8.0.2", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.0.1", "entities": "^4.4.0" } }, "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA=="],
 
     "http-errors": ["http-errors@2.0.1", "", { "dependencies": { "depd": "~2.0.0", "inherits": "~2.0.4", "setprototypeof": "~1.2.0", "statuses": "~2.0.2", "toidentifier": "~1.0.1" } }, "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ=="],
 
@@ -3381,6 +3384,8 @@
 
     "postcss-load-config": ["postcss-load-config@6.0.1", "", { "dependencies": { "lilconfig": "^3.1.1" }, "peerDependencies": { "jiti": ">=1.21.0", "postcss": ">=8.0.9", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["jiti", "postcss", "tsx", "yaml"] }, "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g=="],
 
+    "postcss-media-query-parser": ["postcss-media-query-parser@0.2.3", "", {}, "sha512-3sOlxmbKcSHMjlUXQZKQ06jOswE7oVkXPxmZdoB1r5l0q6gTFTQSHxNxOrCccElbW7dxNytifNEo8qidX2Vsig=="],
+
     "postcss-nested": ["postcss-nested@6.2.0", "", { "dependencies": { "postcss-selector-parser": "^6.1.1" }, "peerDependencies": { "postcss": "^8.2.14" } }, "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ=="],
 
     "postcss-selector-parser": ["postcss-selector-parser@6.0.10", "", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w=="],
@@ -4459,6 +4464,8 @@
 
     "c12/pkg-types": ["pkg-types@2.3.1", "", { "dependencies": { "confbox": "^0.2.4", "exsolve": "^1.0.8", "pathe": "^2.0.3" } }, "sha512-y+ichcgc2LrADuhLNAx8DFjVfgz91pRxfZdI3UDhxHvcVEZsenLO+7XaU5vOp0u/7V/wZ+plyuQxtrDlZJ+yeg=="],
 
+    "cheerio/htmlparser2": ["htmlparser2@10.1.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.2.2", "entities": "^7.0.1" } }, "sha512-VTZkM9GWRAtEpveh7MSF6SjjrpNVNNVJfFup7xTY3UpFtm67foy9HDVXneLtFVt4pMz5kZtgNcvCniNFb1hlEQ=="],
+
     "chrome-launcher/@types/node": ["@types/node@25.9.3", "", { "dependencies": { "undici-types": ">=7.24.0 <7.24.7" } }, "sha512-603BddQMv3pUcr4U2dhujk83N2tTDVr/34wII2B6bJy6g+8WD6yUb11jszNs0gdi4PesVWl7ABt8nYMVpnLUcg=="],
 
     "cli-truncate/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
@@ -4471,6 +4478,8 @@
 
     "concat-stream/readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="],
 
+    "critters/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
     "cross-spawn/which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
 
     "cytoscape-fcose/cose-base": ["cose-base@2.2.0", "", { "dependencies": { "layout-base": "^2.0.0" } }, "sha512-AzlgcsCbUMymkADOJtQm3wO9S3ltPfYOFD5033keQn9NJzIbtnZj+UdBJe7DYml/8TdbtHJW3j58SOnKhWY/5g=="],
@@ -4557,9 +4566,7 @@
 
     "groq-sdk/node-fetch": ["node-fetch@2.7.0", "", { "dependencies": { "whatwg-url": "^5.0.0" }, "peerDependencies": { "encoding": "^0.1.0" }, "optionalPeers": ["encoding"] }, "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A=="],
 
-    "html-to-text/htmlparser2": ["htmlparser2@8.0.2", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.0.1", "entities": "^4.4.0" } }, "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA=="],
-
-    "htmlparser2/entities": ["entities@7.0.1", "", {}, "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA=="],
+    "htmlparser2/entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
 
     "http-response-object/@types/node": ["@types/node@10.17.60", "", {}, "sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw=="],
 
@@ -4929,6 +4936,8 @@
 
     "c12/chokidar/readdirp": ["readdirp@4.1.2", "", {}, "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg=="],
 
+    "cheerio/htmlparser2/entities": ["entities@7.0.1", "", {}, "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA=="],
+
     "chrome-launcher/@types/node/undici-types": ["undici-types@7.24.6", "", {}, "sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg=="],
 
     "cli-truncate/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
@@ -5049,8 +5058,6 @@
 
     "groq-sdk/node-fetch/whatwg-url": ["whatwg-url@5.0.0", "", { "dependencies": { "tr46": "~0.0.3", "webidl-conversions": "^3.0.0" } }, "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw=="],
 
-    "html-to-text/htmlparser2/entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
-
     "inquirer/ora/is-interactive": ["is-interactive@1.0.0", "", {}, "sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w=="],
 
     "inquirer/ora/is-unicode-supported": ["is-unicode-supported@0.1.0", "", {}, "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw=="],