diff --git a/apps/sim/app/(landing)/comparisons/utils.ts b/apps/sim/app/(landing)/comparisons/utils.ts
index 1c896d501fe..97f31b944b4 100644
--- a/apps/sim/app/(landing)/comparisons/utils.ts
+++ b/apps/sim/app/(landing)/comparisons/utils.ts
@@ -100,13 +100,14 @@ export function buildBottomLine(competitor: CompetitorProfile): ComparisonVerdic
     : `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.`,
+    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, human-in-the-loop approvals, and, on the Enterprise plan, environment promotion (dev/qa/prod) and 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
+ * Builds the FAQ set for a "Sim vs {Competitor}" page: the profile's
+ * hand-written FAQs first, then the generated ones. 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,
@@ -116,9 +117,10 @@ export function buildComparisonFaqs(competitor: CompetitorProfile): ComparisonFa
   const name = competitor.name
   const facts = competitor.facts
   const faqs: ComparisonFaq[] = [
+    ...(competitor.faqs ?? []),
     {
       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. ${ensurePeriod(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.`,
+      answer: `Sim is an open-source AI workspace where teams build, deploy, and manage AI agents visually, conversationally, or with code. ${ensurePeriod(competitor.oneLiner)} Teams considering a switch typically weigh licensing (Sim's core 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}?`,
@@ -126,7 +128,7 @@ export function buildComparisonFaqs(competitor: CompetitorProfile): ComparisonFa
     },
     {
       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))}`,
+      answer: `Sim can be self-hosted via Docker or Kubernetes with an Apache 2.0-licensed core, in addition to a managed cloud-hosted plan. Enterprise features such as SSO and audit logs require an Enterprise license. ${name}'s self-hosting position: ${ensurePeriod(firstSentence(facts.platform.selfHostOption.value))}`,
     },
     {
       question: `How does Sim's pricing compare to ${name}?`,
diff --git a/apps/sim/app/(landing)/integrations/data/seo-content.ts b/apps/sim/app/(landing)/integrations/data/seo-content.ts
index 31ef6da86cb..0ec2760bd51 100644
--- a/apps/sim/app/(landing)/integrations/data/seo-content.ts
+++ b/apps/sim/app/(landing)/integrations/data/seo-content.ts
@@ -22,9 +22,337 @@ export const INTEGRATION_SEO: Record<string, IntegrationSeoContent> = {
     h1: 'GitHub Workflow Automation and Integration',
     tagline: 'Build GitHub automation and trigger AI workflows from GitHub events.',
     overview:
-      'Use Sim’s GitHub integration to run GitHub automation inside one AI workspace. Get pull request details, post pull request and issue comments, fetch repository and commit data, and trigger workflows from pull requests, comments, pushes, releases, and GitHub Actions events. Build GitHub workflow automation for code reviews, changelog generation, engineering digests, release operations, and documentation updates.',
+      'Use Sim’s GitHub integration to run GitHub automation inside one AI workspace. Read pull requests, files, and commits; create and update issues, pull requests, branches, files, and releases; post comments and pull request reviews; and start workflows from issue, pull request, push, release, and GitHub Actions events. For example, a PR Opened trigger can start a workflow that fetches the changed files and diffs with Get PR files, then passes them to an Agent block that posts a pull request review with specific suggestions. An Issue Opened trigger can have an agent read the issue, apply labels and an assignee, and post a triage comment. A Release Published trigger can compare commits since the previous tag and send a changelog to Slack.',
     triggersIntro:
-      'Connect a GitHub webhook to Sim and your agent runs the instant an event happens, no polling, no delay.',
+      'Sim supports GitHub webhook triggers for Issue Opened, Issue Closed, Issue Comment, PR Opened, PR Closed, PR Merged, PR Comment, PR Reviewed, Code Push, Release Published, and Actions Workflow Run. Copy the webhook URL Sim generates into your repository’s Settings > Webhooks, and the workflow starts when GitHub delivers the event instead of waiting for a scheduled check.',
+    comparison: {
+      id: 'github-comparison',
+      heading: 'Sim vs. Zapier and n8n for GitHub',
+      intro:
+        'Zapier and n8n both provide GitHub integrations for general-purpose automation. Sim focuses on workflows where an Agent block reads a pull request, issue, or diff before a GitHub block comments, reviews, labels, or opens a pull request. Zapier or n8n may suit a GitHub workflow that relays events without an AI step.',
+      columns: ['Sim', 'Zapier', 'n8n'],
+      rows: [
+        {
+          label: 'Trigger model',
+          values: [
+            {
+              text: 'Real-time webhook',
+            },
+            {
+              text: 'Polling',
+              href: 'https://zapier.com/apps/github/integrations',
+            },
+            {
+              text: 'Webhook',
+              href: 'https://docs.n8n.io/integrations/builtin/trigger-nodes/n8n-nodes-base.githubtrigger',
+            },
+          ],
+        },
+        {
+          label: 'AI step before acting',
+          values: [
+            {
+              text: 'Agent block, built in',
+            },
+            {
+              text: 'Requires a separate AI step or app',
+              href: 'https://zapier.com/apps/github/integrations/chatgpt',
+            },
+            {
+              text: 'Requires a separate AI Agent node',
+              href: 'https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent',
+            },
+          ],
+        },
+        {
+          label: 'Free to start',
+          values: [
+            {
+              text: 'Yes',
+            },
+            {
+              text: 'Yes, 100 tasks a month on two-step Zaps',
+              href: 'https://zapier.com/pricing',
+            },
+            {
+              text: 'Yes, when self-hosted',
+              href: 'https://docs.n8n.io/n8n-community-license',
+            },
+          ],
+        },
+        {
+          label: 'Open pull requests',
+          values: [
+            {
+              text: 'Create pull request operation',
+            },
+            {
+              text: 'Create Pull Request action',
+              href: 'https://zapier.com/apps/github/integrations',
+            },
+            {
+              text: 'Pull Request Create operation',
+              href: 'https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.github',
+            },
+          ],
+        },
+      ],
+      conclusion:
+        'Choose Sim when an AI agent should read the pull request or issue and decide what to comment, label, or change, rather than relay each GitHub event unchanged.',
+    },
+    faqs: [
+      {
+        question: 'Can a Sim agent open pull requests, triage issues, and comment on GitHub?',
+        answer:
+          'Yes. Sim’s GitHub block includes Create pull request, Create issue comment, Create PR comment, Create PR review, Add issue labels, and Add issue assignees, and an Agent block can choose which to run. Issue Opened and PR Opened triggers start the workflow when GitHub delivers the event, so triage and review comments do not wait on a schedule.',
+      },
+      {
+        question: 'What GitHub events can start a Sim workflow?',
+        answer:
+          'Sim has GitHub triggers for Issue Opened, Issue Closed, Issue Comment, PR Opened, PR Closed, PR Merged, PR Comment, PR Reviewed, Code Push, Release Published, and Actions Workflow Run. Each one uses a webhook URL that you add in your repository’s Settings > Webhooks, with an optional webhook secret.',
+      },
+      {
+        question: 'Can Sim use a GitHub MCP server?',
+        answer:
+          'Sim can connect a remote MCP server that uses Streamable HTTP and give its tools to an Agent block or run them through the MCP block; local stdio servers are not supported. Sim does not ship its own GitHub MCP server, and its built-in GitHub block covers pull requests, issues, files, branches, releases, and Actions without one.',
+      },
+      {
+        question: 'How do I connect GitHub to Sim?',
+        answer:
+          'Add a GitHub block to a workflow and enter a GitHub personal access token in its credential field. Choose an operation such as Get PR details or Create issue, or switch the block to trigger mode and pick a GitHub event. Test the workflow, then deploy it to run on live events.',
+      },
+      {
+        question: 'What is the difference between Sim and Zapier for GitHub?',
+        answer:
+          'Zapier’s GitHub triggers poll for new data, and its free plan allows two-step Zaps, so a Zap with an AI step between the trigger and the action needs a paid plan. Sim receives GitHub webhooks directly and includes Agent blocks in every workflow. Choose Sim when an agent should read code or issue context before acting.',
+      },
+    ],
+  },
+  shopify: {
+    title: 'Shopify Automation with Sim',
+    description:
+      'Build Shopify automation in Sim. Manage products, orders, customers, inventory, and fulfillment with AI agents. Free to start.',
+    keywords: ['shopify automation', 'shopify inventory automation', 'shopify integration'],
+    h1: 'Shopify Automation with Sim',
+    tagline:
+      'Build Shopify automation with AI agents in Sim. Manage products, variants, orders, customers, inventory, collections, and fulfillment.',
+    overview:
+      'Connect Shopify to Sim with OAuth and run Shopify automation from one AI workspace. Create and update products and variants, read and update orders, manage customers, check inventory levels by location, adjust inventory quantities, and create fulfillments with tracking. For example, a scheduled workflow can list inventory items, have an Agent block flag variants whose available quantity is below a threshold, and post the list to Slack. An agent can review recent orders and add tags or notes with Update Order. A restock workflow can apply an Adjust Inventory change at a location after an agent checks the received quantity.',
+    comparison: {
+      id: 'shopify-comparison',
+      heading: 'Sim vs. Zapier and n8n for Shopify',
+      intro:
+        'Zapier and n8n both provide Shopify integrations, and both offer Shopify triggers that Sim does not have. Sim focuses on workflows where an Agent block reads inventory, order, or customer data and decides what to change before a Shopify block acts. Zapier or n8n may suit a workflow that must start the moment a Shopify event fires.',
+      columns: ['Sim', 'Zapier', 'n8n'],
+      rows: [
+        {
+          label: 'Trigger model',
+          values: [
+            {
+              text: 'Scheduled; no native Shopify trigger',
+            },
+            {
+              text: 'Instant for most events, including Updated Inventory',
+              href: 'https://zapier.com/apps/shopify/integrations',
+            },
+            {
+              text: 'Webhook',
+              href: 'https://docs.n8n.io/integrations/builtin/trigger-nodes/n8n-nodes-base.shopifytrigger',
+            },
+          ],
+        },
+        {
+          label: 'AI step before acting',
+          values: [
+            {
+              text: 'Agent block, built in',
+            },
+            {
+              text: 'Requires a separate AI step or app',
+              href: 'https://zapier.com/apps/shopify/integrations/chatgpt',
+            },
+            {
+              text: 'Requires a separate AI Agent node',
+              href: 'https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent',
+            },
+          ],
+        },
+        {
+          label: 'Free to start',
+          values: [
+            {
+              text: 'Yes',
+            },
+            {
+              text: 'Yes, 100 tasks a month on two-step Zaps',
+              href: 'https://zapier.com/pricing',
+            },
+            {
+              text: 'Yes, when self-hosted',
+              href: 'https://docs.n8n.io/n8n-community-license',
+            },
+          ],
+        },
+        {
+          label: 'Adjust inventory',
+          values: [
+            {
+              text: 'Adjust Inventory operation',
+            },
+            {
+              text: 'Update Inventory Quantity action',
+              href: 'https://zapier.com/apps/shopify/integrations',
+            },
+            {
+              text: 'No inventory operation in the Shopify node',
+              href: 'https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.shopify',
+            },
+          ],
+        },
+      ],
+      conclusion:
+        'Choose Sim when an AI agent should review inventory and order data and decide what to flag or change on a schedule, rather than react to each Shopify event with a fixed action.',
+    },
+    faqs: [
+      {
+        question: 'Can a Sim agent update Shopify inventory and flag low stock?',
+        answer:
+          'Yes, on a schedule. Sim’s Shopify block can list inventory items with available and on-hand quantities, get an inventory level at a location, and change a variant’s quantity by a set amount with Adjust Inventory. A Schedule trigger can run an Agent block that flags low-stock variants and posts them to Slack, because Sim has no Shopify trigger that fires when inventory changes.',
+      },
+      {
+        question: 'What Shopify order and inventory operations does Sim support?',
+        answer:
+          'Sim supports Get Order, List Orders, Update Order (note, tags, and email), and Cancel Order, plus List Inventory Items, Get Inventory Level, Adjust Inventory, and List Locations. Fulfillment operations include Create Fulfillment, List Fulfillment Orders, and Update Fulfillment Tracking. Product, variant, customer, and collection operations are also available.',
+      },
+      {
+        question: 'Does Sim have Shopify triggers?',
+        answer:
+          'No. Sim does not have a native Shopify trigger, so Shopify workflows in Sim usually start from a Schedule trigger or another trigger in the workflow. If a workflow must start the moment an order or inventory event fires, Zapier and n8n both offer Shopify triggers.',
+      },
+      {
+        question: 'How do I connect Shopify to Sim?',
+        answer:
+          'Add a Shopify block to a workflow and connect your store with OAuth. Choose an operation such as List Orders or Adjust Inventory, test the workflow, and deploy it. Orders normally cover the last 60 days, and older orders and protected customer fields require Shopify approval.',
+      },
+      {
+        question: 'What is the difference between Sim and Zapier for Shopify?',
+        answer:
+          'Zapier offers instant Shopify triggers and inventory actions, but its free plan allows two-step Zaps, so a Zap with an AI step between the trigger and the action needs a paid plan. Sim includes Agent blocks in every workflow and runs Shopify checks on a schedule. Choose Sim when an agent should decide which products, orders, or quantities need attention.',
+      },
+    ],
+  },
+  snowflake: {
+    title: 'Snowflake Automation with Sim',
+    description:
+      'Build Snowflake automation in Sim. Run SQL, ask Cortex Analyst, and manage warehouses and tasks with AI agents. Free to start.',
+    keywords: ['snowflake automation', 'snowflake ai agent', 'snowflake integration'],
+    h1: 'Snowflake Automation with Sim',
+    tagline:
+      'Build Snowflake automation with AI agents in Sim. Run SQL, ask Cortex Analyst, sync rows, and manage warehouses and tasks.',
+    overview:
+      'Connect Snowflake to Sim with a programmatic access token and run Snowflake automation from one AI workspace. Execute parameterized SQL; insert, update, upsert, and delete rows; load and unload staged data; browse databases, schemas, and tables; control warehouses and tasks; review query history; and call stored procedures. For example, a scheduled workflow can run Execute SQL against a revenue table, have an Agent block summarize the change since last week, and post the summary to Slack. An agent can answer a team question with Ask Cortex Analyst against a semantic view and return the generated SQL and results. A data operations workflow can check List Task Runs and rerun a failed task with Run Task.',
+    comparison: {
+      id: 'snowflake-comparison',
+      heading: 'Sim vs. Zapier and n8n for Snowflake',
+      intro:
+        'Zapier and n8n both connect to Snowflake for SQL and row operations. Sim focuses on workflows where an Agent block queries Snowflake, interprets the results, and sends the insight to a tool such as Slack. None of the three receives instant events from Snowflake: Zapier polls for new rows, while Sim and n8n workflows start from a schedule or another trigger.',
+      columns: ['Sim', 'Zapier', 'n8n'],
+      rows: [
+        {
+          label: 'Trigger model',
+          values: [
+            {
+              text: 'Scheduled; no native Snowflake trigger',
+            },
+            {
+              text: 'Polling for new or updated rows',
+              href: 'https://zapier.com/apps/snowflake/integrations',
+            },
+            {
+              text: 'No Snowflake trigger node',
+              href: 'https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.snowflake',
+            },
+          ],
+        },
+        {
+          label: 'AI step before acting',
+          values: [
+            {
+              text: 'Agent block, built in',
+            },
+            {
+              text: 'Requires a separate AI step or app',
+              href: 'https://zapier.com/apps/snowflake/integrations/chatgpt',
+            },
+            {
+              text: 'Requires a separate AI Agent node',
+              href: 'https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent',
+            },
+          ],
+        },
+        {
+          label: 'Free to start',
+          values: [
+            {
+              text: 'Yes',
+            },
+            {
+              text: 'Yes, 100 tasks a month on two-step Zaps',
+              href: 'https://zapier.com/pricing',
+            },
+            {
+              text: 'Yes, when self-hosted',
+              href: 'https://docs.n8n.io/n8n-community-license',
+            },
+          ],
+        },
+        {
+          label: 'Natural-language questions',
+          values: [
+            {
+              text: 'Ask Cortex Analyst operation',
+            },
+            {
+              text: 'SQL and row actions only',
+              href: 'https://zapier.com/apps/snowflake/integrations',
+            },
+            {
+              text: 'SQL query, insert, and update only',
+              href: 'https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.snowflake',
+            },
+          ],
+        },
+      ],
+      conclusion:
+        'Choose Sim when an AI agent should query Snowflake, interpret the results, and deliver the insight, rather than move rows between tools unchanged.',
+    },
+    faqs: [
+      {
+        question: 'Which AI agent builders integrate with Snowflake for data queries?',
+        answer:
+          'Sim integrates with Snowflake through a block that runs parameterized SQL, lists databases, schemas, and tables, inspects schemas, and asks Cortex Analyst questions in natural language. An Agent block can choose the query, read the results, and pass them to later steps. Zapier and n8n also connect to Snowflake for SQL and row operations.',
+      },
+      {
+        question: 'Can Sim query Snowflake and post insights to Slack?',
+        answer:
+          'Yes. A Sim workflow can run Execute SQL or Ask Cortex Analyst, have an Agent block summarize the results, and send the summary with a Slack block. Start it with a Schedule trigger for recurring reports, because Sim has no trigger that fires on Snowflake data changes.',
+      },
+      {
+        question: 'Does Sim support an MCP server for querying Snowflake?',
+        answer:
+          'Sim can connect a remote MCP server that uses Streamable HTTP and give its tools to an Agent block, so a Snowflake MCP server your team runs can be added as agent tools. Sim does not ship its own Snowflake MCP server, and its built-in Snowflake block runs SQL and Cortex Analyst without one. Sim can also expose a deployed workflow, such as one that runs a Snowflake query, as a tool on an MCP server for external MCP clients.',
+      },
+      {
+        question: 'How do I connect Snowflake to Sim?',
+        answer:
+          'Create a Snowflake programmatic access token, add a Snowflake block to a workflow, and enter the token with your account details. Choose an operation such as Execute SQL or List Tables, test the workflow, and deploy it. Execute SQL runs whatever SQL the workflow passes it, so scope the token’s role to the data the workflow needs.',
+      },
+      {
+        question: 'What is the difference between Sim and n8n for Snowflake?',
+        answer:
+          'n8n’s Snowflake node runs SQL queries and inserts or updates rows, and adding AI requires a separate AI Agent node. Sim’s Snowflake block also covers upserts, staged loads and unloads, warehouses, tasks, query history, stored procedures, and Cortex Analyst, with Agent blocks built into every workflow.',
+      },
+    ],
   },
   outlook: {
     title: 'Outlook Automation with Sim',
@@ -172,7 +500,7 @@ export const INTEGRATION_SEO: Record<string, IntegrationSeoContent> = {
             },
             {
               text: 'Yes, when self-hosted',
-              href: 'https://docs.n8n.io/privacy-and-security/sustainable-use-license/',
+              href: 'https://docs.n8n.io/n8n-community-license',
             },
           ],
         },
diff --git a/apps/sim/lib/compare/data/competitors/dust.ts b/apps/sim/lib/compare/data/competitors/dust.ts
index 2e6aebed4cb..ce53ce1e09e 100644
--- a/apps/sim/lib/compare/data/competitors/dust.ts
+++ b/apps/sim/lib/compare/data/competitors/dust.ts
@@ -44,6 +44,24 @@ export const dustProfile: CompetitorProfile = {
       'Both products provide documentation and learning resources. Sim emphasizes its open-source community and an Enterprise dedicated-support option, while Dust also documents community forums and enterprise onboarding.',
     ],
   },
+  faqs: [
+    {
+      question:
+        'We use Dust for company knowledge but need real workflow automation too. What should we look at?',
+      answer:
+        "Sim is worth evaluating when Dust's knowledge agents need to run inside multi-step automations. Dust builds agents from instructions, tools, and connected data sources, and offers no loop container or branch-and-join execution model. Sim adds a visual workflow canvas with loops, parallel branches, error-handling paths, and human approval steps, started by webhooks, schedules, API calls, or events from connected apps.",
+    },
+    {
+      question: 'Sim vs Dust for building company knowledge agents: which is better?',
+      answer:
+        "It depends on where the agent needs to live. Dust connects agents to sources such as Slack, Notion, Google Drive, Confluence, and GitHub and serves them in its web chat, Slack, and Microsoft Teams, with access scoped by Spaces. Sim's knowledge base combines vector and full-text search over 12 document formats with connectors that keep sources such as Google Drive, Confluence, and Slack in sync, and a knowledge agent can be published as a chat interface, a REST API, or an MCP server. Dust suits a managed assistant used mainly in chat; Sim suits a knowledge agent that also has to feed workflows or other systems.",
+    },
+    {
+      question: 'How does Sim compare to Dust for shared team AI assistants?',
+      answer:
+        'Both are built for teams, but they share different things. Dust shares agents and conversations: people and agents work in a common workspace, access is set by roles plus Spaces, and Pro seats cost $30 or €30 per month ($24 or €24 per month billed annually) with 8,000 credits each. Sim shares the build: several people can edit the same workflow canvas live, workspaces carry admin, write, and read permissions, and the Pro plan is $25 per user per month.',
+    },
+  ],
   standoutFeatures: [
     {
       title:
@@ -195,29 +213,34 @@ export const dustProfile: CompetitorProfile = {
         value:
           "No: the core repository is MIT-licensed and public on GitHub, but self-hosting isn't an officially supported deployment path; Dust is sold and operated only as hosted SaaS",
         detail:
-          'dust-tt/dust is publicly available and MIT-licensed, but Dust the company documents only its hosted product (with US/EU region choice), not a supported self-managed installation.',
+          'dust-tt/dust is publicly available and MIT-licensed, but Dust documents only its hosted product: US or EU data residency on Business, plus single-tenant deployment on Enterprise. It does not document a supported self-managed installation.',
         shortValue: 'No, MIT code exists but only SaaS is supported',
         confidence: 'estimated',
         sources: [
           {
             url: 'https://github.com/dust-tt/dust/blob/main/LICENSE',
             label: 'dust-tt/dust LICENSE (GitHub)',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://dust.tt/home/pricing',
+            label: 'Dust Pricing',
+            asOf: '2026-10-15',
           },
         ],
       },
       deploymentOptions: {
         value:
-          'Multi-tenant hosted cloud by default; an EU data-hosting option for databases, files, and vectors is available, documented as exclusive to Enterprise customers rather than a self-serve region choice on every tier',
+          'Hosted cloud only, with US or EU data residency on the Business plan and single-tenant deployment on Enterprise',
         detail:
-          "Dust's changelog states the EU data hosting option is 'available exclusively for enterprise customers' and covers 'storage of databases, files, and vectors' (calls to third-party LLM provider APIs remain outside this hosting boundary). No Dust source documents a selectable US-region toggle or a named single-tenant deployment tier.",
-        shortValue: 'Multi-tenant cloud by default; EU data hosting is Enterprise-exclusive',
-        confidence: 'estimated',
+          'Dust\'s pricing page lists "US & EU data residency" on Business and "US & EU data residency & single-tenant deployment" on Enterprise. Calls to third-party LLM provider APIs remain outside the hosting boundary.',
+        shortValue: 'Hosted cloud; US/EU residency, single-tenant on Enterprise',
+        confidence: 'verified',
         sources: [
           {
-            url: 'https://docs.dust.tt/docs/changelog#-eu-data-hosting-option-available',
-            label: 'EU data hosting option available | Dust changelog',
-            asOf: '2026-07-08',
+            url: 'https://dust.tt/home/pricing',
+            label: 'Dust Pricing',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -247,7 +270,7 @@ export const dustProfile: CompetitorProfile = {
           {
             url: 'https://github.com/dust-tt/dust/blob/main/LICENSE',
             label: 'dust-tt/dust LICENSE (GitHub)',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -752,61 +775,74 @@ export const dustProfile: CompetitorProfile = {
     },
     pricing: {
       pricingModel: {
-        value: 'Per-seat subscription with a monthly AI-usage credit allocation per seat',
+        value:
+          'Per-seat subscription (Free, Pro, and Max seat types on the Business plan, for teams up to 100 people) with a monthly AI-usage credit allocation per paid seat; Enterprise is sales-led',
         detail:
-          'Business plan seats (Pro, Max) each include a monthly credit allocation that resets every billing period; credit consumption depends on the model used, task complexity, and any tools the agent invokes (search, retrieval, code execution, connected-app actions).',
+          'Pro and Max seats each include a monthly credit allocation that resets every billing period. Credits are charged per message based on the model used and the actions performed.',
         shortValue: 'Per-seat pricing with monthly credit allocations',
         confidence: 'verified',
         sources: [
           {
             url: 'https://dust.tt/home/pricing',
             label: 'Dust Pricing',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
       entryPaidPlan: {
-        value: 'Business Pro: $30/month per seat ($24/month billed yearly), 8,000 credits/month',
+        value:
+          'Business Pro seat: 30/month per seat (24/month billed yearly), 8,000 credits per seat per month; shown in dollars in the US and euros elsewhere, excluding VAT',
         detail:
-          "The Business plan's Pro tier is the entry paid tier above the free plan; a higher Max tier ($150/month, or $120/month billed yearly) includes 40,000 credits/month.",
-        shortValue: '$30/month per seat (or $24/month annual), 8,000 credits',
+          'Pro is the entry paid seat above the Free seat. The higher Max seat is 150/month (120/month billed yearly) with 40,000 credits per seat per month. The pricing page shows dollars to US visitors and euros elsewhere, with the same amounts, excluding VAT.',
+        shortValue: '$30 or €30/seat/month ($24 or €24/month billed annually), 8,000 credits',
         confidence: 'verified',
         sources: [
           {
             url: 'https://dust.tt/home/pricing',
             label: 'Dust Pricing',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
       freeTier: {
         value:
-          'Yes: a free Business tier for new workspaces, capped at 5 users, 3 connectors, and 5 Spaces, no credit card required',
+          'Yes: a free Business option for new workspaces (no credit card, up to 5 users, 3 connectors, 5 Spaces); each Free seat gets a one-time allocation of 500 credits that does not renew',
         detail:
-          'This free tier is what a new workspace gets by default without a paid subscription. It is distinct from what happens when an existing paid workspace downgrades: canceling removes all users except the earliest-assigned admin, deletes existing connections, and deletes data sources over 50MB combined after a 7-day warning period, while original source data in the connected provider itself is untouched.',
-        shortValue: 'Free for new workspaces: up to 5 users, 3 connectors, 5 Spaces',
+          'The Free seat works as a trial: a member can hold it only once. Cancelling a paid subscription does not switch the workspace back to the free option; the subscription stays active until the end of the billing period, and by default Dust deletes the workspace data 30 days after that.',
+        shortValue: 'Free: up to 5 users, 500 one-time credits per seat',
         confidence: 'verified',
         sources: [
           {
             url: 'https://dust.tt/home/pricing',
             label: 'Dust Pricing',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
           {
             url: 'https://docs.dust.tt/docs/subscriptions',
             label: 'Subscriptions & Payments | Dust Docs',
-            asOf: '2026-07-04',
+            asOf: '2026-10-15',
           },
         ],
       },
       byok: {
         value:
-          'No dedicated BYOK program: Dust bills usage via plan-included AI credits rather than a bring-your-own-provider-API-key option',
+          'Not documented: Dust bills model usage through its own plan-included credits, and neither its pricing page nor its credits docs describe supplying your own provider API key',
         detail:
-          'Pricing is structured around per-seat monthly credits that scale with model/task/tool complexity; no Dust source describes letting a workspace supply its own OpenAI/Anthropic API key in place of credit consumption.',
+          'The pricing page states that all plans include access to 20+ models from OpenAI, Anthropic, Google, Mistral, and DeepSeek, consumed as Dust credits per message.',
         shortValue: 'Not documented; usage billed via included credits',
-        confidence: 'unknown',
-        sources: [],
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://dust.tt/home/pricing',
+            label: 'Dust Pricing',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://docs.dust.tt/docs/credits',
+            label: 'Credits | Dust Docs',
+            asOf: '2026-10-15',
+          },
+        ],
       },
     },
     security: {
diff --git a/apps/sim/lib/compare/data/competitors/gumloop.ts b/apps/sim/lib/compare/data/competitors/gumloop.ts
index 936f979c68f..06edfdb6878 100644
--- a/apps/sim/lib/compare/data/competitors/gumloop.ts
+++ b/apps/sim/lib/compare/data/competitors/gumloop.ts
@@ -23,6 +23,26 @@ export const gumloopProfile: CompetitorProfile = {
   },
   oneLiner:
     'Gumloop is a hosted, no-code visual platform for building and deploying AI agents and automations: a drag-and-drop canvas, an AI copilot ("Gen") for natural-language flow creation, and native MCP (Model Context Protocol) integration support.',
+  leadAnswer: [
+    "Gumloop is a hosted, proprietary no-code platform for building AI agents and automations, sold as a $37/month Pro plan or a custom Enterprise plan, with deployment into the customer's own cloud (VPC) as an optional Enterprise add-on. Sim is an open-source AI workspace with an Apache 2.0-licensed core for building, deploying, and managing agents visually, conversationally, or with code, available as a managed cloud or self-hosted with Docker Compose or Kubernetes. Choose Gumloop when you want a fully managed product aimed at non-technical business users, or a vendor-supported deployment inside your own cloud. Choose Sim when you need to run and inspect the platform yourself or want to start on a free plan.",
+  ],
+  faqs: [
+    {
+      question: 'Can I self-host Gumloop agents, or do I need a platform like Sim?',
+      answer:
+        "Gumloop has no public self-hosted install: its app is proprietary, and the closest option is an optional Enterprise deployment into your own cloud (VPC). Sim's core is Apache 2.0 licensed and can be self-hosted with Docker Compose or Kubernetes (Helm), so your team runs the whole platform. On Gumloop's VPC option, compute is not billed in credits because it runs on your infrastructure, but model, tool-call, and orchestration charges still apply.",
+    },
+    {
+      question: 'How do Sim and Gumloop compare for running AI agent workflows in production?',
+      answer:
+        "Sim gives each tool or API call configurable exponential-backoff retries (up to 10 attempts) and lets any block route failures to an error branch, while Gumloop documents no automatic retries or run replay and handles failures through a manual Error Shield node. Both alert on failures: Gumloop sends failure emails on Pro and above, and Sim's workspace-event trigger can push run failures and cost or latency spikes to Slack, email, or a webhook. Sim publishes its run ceilings (5-minute sync runs on Free, 50 minutes on paid plans, 90-minute async by default), while Gumloop publishes concurrency (5 concurrent runs on Pro) but no maximum run duration.",
+    },
+    {
+      question: 'Is Gumloop open source, and is Sim?',
+      answer:
+        "Gumloop is not: its platform is proprietary, and its public GitHub repositories are client SDKs, forks, and an archived MCP-server project, not the app itself. Sim's core is open source under the Apache 2.0 license and can be self-hosted, with enterprise features such as SSO and audit logs under a separate license. That matters for teams that want to audit or modify the code their agents run on.",
+    },
+  ],
   standoutFeatures: [
     {
       title: '250+ fully hosted MCP servers',
@@ -159,21 +179,21 @@ export const gumloopProfile: CompetitorProfile = {
       },
       selfHostOption: {
         value:
-          'No public self-host option for the core Gumloop app; enterprise customers can get a managed Virtual Private Cloud (VPC) deployment into their own cloud (e.g. GCP) instead of full self-hosting',
+          'No public self-host option for the Gumloop app; Enterprise customers can optionally deploy it into their own cloud (VPC) in a region of their choice',
         detail:
-          "Gumloop deploys and operates the platform inside the customer's cloud project rather than offering a downloadable, self-managed open-source install. Gumloop's own guMCP_template repo is an open-source starter for self-hosted MCP servers, but it is not an install of the Gumloop app itself.",
-        shortValue: 'No self-host; VPC deployment only',
-        confidence: 'estimated',
+          'There is no downloadable, self-managed install. VPC deployment is an optional Enterprise add-on, and VPC organizations are not charged credits for compute because it runs on their infrastructure.',
+        shortValue: 'No self-host; optional Enterprise VPC',
+        confidence: 'verified',
         sources: [
           {
             url: 'https://www.gumloop.com/solutions/security',
             label: 'Gumloop Security & Trust',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
           {
-            url: 'https://github.com/gumloop/guMCP_template',
-            label: "guMCP_template (Gumloop's self-hosted MCP starter repo)",
-            asOf: '2026-07-02',
+            url: 'https://docs.gumloop.com/core-concepts/credits',
+            label: 'Gumloop Docs: Credits (VPC compute)',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -208,11 +228,15 @@ export const gumloopProfile: CompetitorProfile = {
       license: {
         value: 'Proprietary',
         detail:
-          "The core Gumloop application has no open-source license; it is a closed, hosted commercial SaaS product. Gumloop's own guMCP_template repo is an open-source MCP-server starter, but it is not the Gumloop platform.",
+          "The Gumloop application is closed, hosted commercial software. Gumloop's public GitHub repositories are client SDKs (gumloop-py, gumloop-js, Apache-2.0), forks, and an archived GPL-3.0 MCP-server project, not the platform itself.",
         shortValue: 'Proprietary',
         confidence: 'estimated',
         sources: [
-          { url: 'https://www.gumloop.com/pricing', label: 'Gumloop Pricing', asOf: '2026-07-02' },
+          {
+            url: 'https://github.com/gumloop',
+            label: 'Gumloop GitHub organization',
+            asOf: '2026-10-15',
+          },
         ],
       },
       environmentPromotion: {
@@ -562,7 +586,7 @@ export const gumloopProfile: CompetitorProfile = {
         value:
           'Partial: Loop Mode runs multiple list items concurrently (up to 15 at once on the Pro plan), but there is no documented dedicated node for splitting a single run into distinct parallel branches that later join, comparable to a fan-out/fan-in construct',
         detail:
-          'Gumloop docs describe Loop Mode as processing list items simultaneously rather than one at a time, with concurrency limits tied to plan tier (2 concurrent items on Free, 15 on Pro). This is data-parallelism over a list, not branch-level fan-out/fan-in across different paths of logic.',
+          'Gumloop docs describe Loop Mode as processing list items simultaneously rather than one at a time, with concurrency limits tied to plan tier (15 concurrent items on Pro). This is data-parallelism over a list, not branch-level fan-out/fan-in across different paths of logic.',
         shortValue:
           'Partial: concurrent list-item processing (Loop Mode), no branch fan-out/fan-in node',
         confidence: 'estimated',
@@ -596,7 +620,7 @@ export const gumloopProfile: CompetitorProfile = {
       },
       loopIteration: {
         value:
-          "Partial: Gumloop's only documented iteration primitive is 'Loop Mode', the same mechanism covered under parallelExecution, which a user manually enables on a node so it runs once per item in a connected list. Per Gumloop's docs this is concurrent (2 items at once on Free, 15 on Pro), not a strictly one-at-a-time sequential container, and no separate while-loop or fixed-iteration-count node is documented, only manually-enabled iteration over an existing list.",
+          "Partial: Gumloop's only documented iteration primitive is 'Loop Mode', the same mechanism covered under parallelExecution, which a user manually enables on a node so it runs once per item in a connected list. Per Gumloop's docs this is concurrent (15 items at once on Pro), not a strictly one-at-a-time sequential container, and no separate while-loop or fixed-iteration-count node is documented, only manually-enabled iteration over an existing list.",
         detail:
           "Gumloop docs describe Loop Mode as a mode a user enables on a node ('When you enable Loop Mode on a node...'), which then processes multiple list items simultaneously with concurrency capped by plan tier, distinct from a classic for-each node that guarantees one iteration finishes before the next starts. No dedicated while-loop (condition-based) or fixed-count repeat node is documented; all iteration requires manually enabling Loop Mode with a list as input.",
         shortValue: 'Partial: manually-enabled Loop Mode is concurrent, not a sequential loop node',
@@ -750,43 +774,76 @@ export const gumloopProfile: CompetitorProfile = {
     pricing: {
       pricingModel: {
         value:
-          'Usage-based monthly credit system (credits consumed per task/run), with tiered monthly credit allotments from 5k (free) up to 1.5M+ on paid tiers, plus seat-based distinctions between Free/Pro/Enterprise',
-        shortValue: 'Credit-based usage across tiered plans',
+          'Usage-based credits indexed at $0.005 each: Pro includes 20,000 credits per month and Enterprise is custom. Each agent run bills the list cost of model tokens, compute (5 credits per session-minute on the managed cloud; Enterprise VPC deployments are not charged for compute), and tool calls, plus an 8% orchestration fee',
+        detail:
+          'Pro credits reset monthly and do not roll over (Enterprise credits do). Pro overage is capped at 1,000,000 credits per billing period by default. Enterprise plans can negotiate a different orchestration fee.',
+        shortValue: 'Credits at $0.005 each plus an 8% orchestration fee',
         confidence: 'verified',
         sources: [
-          { url: 'https://www.gumloop.com/pricing', label: 'Gumloop Pricing', asOf: '2026-07-02' },
+          {
+            url: 'https://www.gumloop.com/pricing',
+            label: 'Gumloop Pricing',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://docs.gumloop.com/core-concepts/credits',
+            label: 'Gumloop Docs: Credits',
+            asOf: '2026-10-15',
+          },
         ],
       },
       entryPaidPlan: {
         value:
-          'Pro plan at $37/month for 20k+ credits. Includes unlimited seats/teams, 5 concurrent runs, 25 concurrent agent interactions, agent reflections, unified billing, and 1 hosted MCP server instance',
-        detail:
-          "Gumloop's pricing page lists 'MCP Server Hosting (1)' under the Pro plan without clarifying its scope: it is not stated whether this cap limits access to the 100+ pre-built, zero-setup MCP servers described on gumloop.com/mcp, or only applies to a separate custom MCP server that Gumloop hosts on a customer's behalf. That distinction is not resolved anywhere on Gumloop's own pricing or MCP pages.",
-        shortValue: '$37/month Pro plan, 20k+ credits',
+          'Pro plan at $37/month with 20,000 credits/month (7,400 at list price plus 12,600 bonus credits), unlimited seats and teams, 5 concurrent workflow runs, 25 concurrent agent chats, and 1 hosted MCP server',
+        shortValue: '$37/month Pro, 20,000 credits/month',
         confidence: 'verified',
         sources: [
-          { url: 'https://www.gumloop.com/pricing', label: 'Gumloop Pricing', asOf: '2026-07-02' },
+          {
+            url: 'https://www.gumloop.com/pricing',
+            label: 'Gumloop Pricing',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://docs.gumloop.com/core-concepts/credits',
+            label: 'Gumloop Docs: Credits',
+            asOf: '2026-10-15',
+          },
         ],
       },
       freeTier: {
         value:
-          'Yes: Free plan with 5,000 credits/month, 1 seat, 1 active trigger, 2 concurrent runs, 5 concurrent agent interactions, unlimited agents/flows, forum-only support',
-        shortValue: '5,000 credits/month, 1 seat',
+          'No free plan: every new account gets a one-time 14-day free trial of Pro that requires a card and rolls into a paid $37/month Pro subscription unless cancelled',
+        detail: 'The plans table lists only Pro ($37/month) and Enterprise (custom).',
+        shortValue: 'No free plan; 14-day Pro trial, card required',
         confidence: 'verified',
         sources: [
-          { url: 'https://www.gumloop.com/pricing', label: 'Gumloop Pricing', asOf: '2026-07-02' },
+          {
+            url: 'https://docs.gumloop.com/core-concepts/credits',
+            label: 'Gumloop Docs: Credits (plans and trial)',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://www.gumloop.com/pricing',
+            label: 'Gumloop Pricing',
+            asOf: '2026-10-15',
+          },
         ],
       },
       byok: {
-        value: 'Yes: Bring Your Own API Keys is supported across all plans',
-        shortValue: 'Supported on all plans',
+        value:
+          'Yes, on Pro and Enterprise: with your own model-provider key, token credits drop to zero but the orchestration fee rises from 8% to 16% of what the run would have cost at list price',
+        shortValue: 'Pro and up; token credits waived, fee rises to 16%',
         confidence: 'verified',
         sources: [
-          { url: 'https://www.gumloop.com/pricing', label: 'Gumloop Pricing', asOf: '2026-07-02' },
           {
-            url: 'https://www.gumloop.com/solutions/security',
-            label: 'Gumloop Security & Trust',
-            asOf: '2026-07-02',
+            url: 'https://www.gumloop.com/pricing',
+            label: 'Gumloop Pricing (BYOK FAQ)',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://docs.gumloop.com/core-concepts/credits',
+            label: 'Gumloop Docs: Credits (How BYOK works)',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -1101,16 +1158,16 @@ export const gumloopProfile: CompetitorProfile = {
       },
       executionLimits: {
         value:
-          'Gumloop publishes concurrency limits by plan on its pricing page: Free allows 2 concurrent runs and 5 concurrent agent interactions, Pro allows 5 concurrent runs and 25 concurrent agent interactions, and Enterprise has custom, unpublished limits. Gumloop does not publicly document a maximum execution duration or per-request timeout for a single workflow run.',
+          'Gumloop publishes concurrency limits by plan on its pricing page: Pro allows 5 concurrent workflow runs and 25 concurrent agent chats, and Enterprise limits are custom. Gumloop does not publicly document a maximum execution duration or per-request timeout for a single workflow run.',
         detail:
-          "Numbers taken directly from the pricing page comparison table. No max single-execution runtime or timeout figure is published in Gumloop's docs, forum, or pricing page.",
-        shortValue: '2-5 concurrent runs by plan; no published timeout',
+          "Numbers taken from the pricing page comparison table. No max single-execution runtime or timeout figure is published in Gumloop's docs or pricing page.",
+        shortValue: '5 concurrent runs on Pro; no published timeout',
         confidence: 'verified',
         sources: [
           {
             url: 'https://www.gumloop.com/pricing',
-            label: 'Gumloop Pricing (concurrent runs / agent interactions by plan)',
-            asOf: '2026-07-02',
+            label: 'Gumloop Pricing (concurrency by plan)',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -1153,11 +1210,11 @@ export const gumloopProfile: CompetitorProfile = {
     support: {
       supportChannels: {
         value:
-          'Forum support on Free plan, escalating to dedicated Slack support on higher/Enterprise plans',
-        shortValue: 'Forum on Free, Slack on higher tiers',
+          'Email support on Pro and dedicated Slack support on Enterprise, plus the Gumloop University learning resource',
+        shortValue: 'Email on Pro, dedicated Slack on Enterprise',
         confidence: 'estimated',
         sources: [
-          { url: 'https://www.gumloop.com/pricing', label: 'Gumloop Pricing', asOf: '2026-07-02' },
+          { url: 'https://www.gumloop.com/pricing', label: 'Gumloop Pricing', asOf: '2026-10-15' },
         ],
       },
       sla: {
diff --git a/apps/sim/lib/compare/data/competitors/langflow.ts b/apps/sim/lib/compare/data/competitors/langflow.ts
index c481c2f9548..67cca3df7f3 100644
--- a/apps/sim/lib/compare/data/competitors/langflow.ts
+++ b/apps/sim/lib/compare/data/competitors/langflow.ts
@@ -15,6 +15,26 @@ export const langflowProfile: CompetitorProfile = {
   },
   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).',
+  leadAnswer: [
+    "Langflow is an open-source, MIT-licensed, Python-based visual builder for AI agents and RAG applications, backed by IBM; since DataStax removed its hosted Langflow from Astra in April 2026, it runs on infrastructure you operate (Desktop, Docker, or Kubernetes). Sim is an open-source AI workspace with an Apache 2.0-licensed core for building, deploying, and managing agents visually, conversationally, or with code, offered as a managed cloud or self-hosted with Docker Compose or Kubernetes. Choose Langflow when you want to edit every component's Python source and work directly in the LangChain ecosystem. Choose Sim when you need documented production controls (failure alerts, error-handling branches, human approval steps, published execution limits) or a managed hosted plan.",
+  ],
+  faqs: [
+    {
+      question: 'Which is more production-ready for agent workflows, Sim or Langflow?',
+      answer:
+        "Sim documents more production controls out of the box: alerts on failures and cost or latency spikes to Slack, email, or a webhook; error branches so one failing block does not halt a run; tool-call retries with exponential backoff; and published timeouts (50-minute sync runs on paid plans, 90-minute async by default). Langflow's public documentation does not describe failure alerting, per-step error routing, retries or replay, or execution limits for flows, though it captures per-step traces and can forward them to LangSmith, Langfuse, or LangWatch. In a self-hosted Langflow deployment, limits are whatever your own infrastructure and worker configuration allow.",
+    },
+    {
+      question: 'How do Sim and Langflow compare for building agent workflows?',
+      answer:
+        "Both are visual canvas builders with a natural-language assistant, but Langflow leans developer-first: every component's Python source is editable, and its docs assume familiarity with LangChain concepts such as embeddings and vector stores. Sim offers a visual canvas, a Chat and Copilot surface that builds and edits workflows from plain-language requests, and code via API and SDK. Sim also has live multiplayer editing and a dedicated approval block that pauses a run for human sign-off, neither of which Langflow documents.",
+    },
+    {
+      question: 'Is there still a hosted version of Langflow?',
+      answer:
+        'DataStax removed its hosted Langflow from Astra on April 9, 2026, and pointed users to Langflow OSS, so the documented ways to run Langflow today are Langflow Desktop or your own Python, Docker, or Kubernetes deployment. IBM sells Elite Support for Langflow OSS and a watsonx Orchestrate integration, with no published pricing. Sim offers both a managed cloud with a Free plan and self-hosting with Docker Compose or Kubernetes.',
+    },
+  ],
   standoutFeatures: [
     {
       title: 'Deep LangChain/Python component ecosystem',
@@ -114,26 +134,31 @@ export const langflowProfile: CompetitorProfile = {
       },
       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.',
+          'Yes: Langflow is open source (MIT) and self-hosted via a Python package (uv/pip), Docker, source, or Kubernetes Helm charts, or run locally as Langflow Desktop. The DataStax-hosted offering was removed from Astra on April 9, 2026',
         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',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://docs.langflow.org/deployment-kubernetes-dev',
+            label: 'Langflow Docs: Kubernetes deployment',
+            asOf: '2026-10-15',
           },
           {
             url: 'https://github.com/langflow-ai/langflow',
             label: 'GitHub: langflow-ai/langflow',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
       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',
+          'Langflow can run as a desktop app on Windows/macOS, a local pip/uv install, a Docker container, or a Kubernetes deployment. Multi-worker setups are documented for scaling self-hosted instances. DataStax removed its hosted Langflow from Astra on April 9, 2026.',
+        shortValue: 'Desktop, local, Docker/K8s, self-hosted',
         confidence: 'verified',
         sources: [
           {
@@ -180,7 +205,7 @@ export const langflowProfile: CompetitorProfile = {
           {
             url: 'https://github.com/langflow-ai/langflow',
             label: 'GitHub: langflow-ai/langflow (License: MIT)',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -634,43 +659,55 @@ export const langflowProfile: CompetitorProfile = {
     pricing: {
       pricingModel: {
         value:
-          "Langflow's core software is free and open source, with no license fee for self-hosting. Third-party sources describe Langflow Cloud as offering a free account tier plus a paid tier around $25 per month for higher usage limits, and separate enterprise pricing; Langflow's official pricing page does not confirm these figures directly.",
-        detail:
-          "Based on third-party summaries; the official pricing page doesn't confirm these figures.",
-        shortValue: 'Free open-source core; cloud free tier plus paid/enterprise tiers',
+          "Free, open-source (MIT) software with no license fee and no published paid plan. DataStax's hosted Langflow was removed from Astra on April 9, 2026, and IBM's listed commercial options (IBM Elite Support for Langflow OSS and a watsonx Orchestrate integration) carry no public price",
+        shortValue: 'Free MIT software; no published paid plan',
         confidence: 'estimated',
         sources: [
           {
-            url: 'https://www.lindy.ai/blog/langflow-pricing',
-            label: 'Lindy: Langflow Pricing',
-            asOf: '2026-07-02',
+            url: 'https://github.com/langflow-ai/langflow',
+            label: 'GitHub: langflow-ai/langflow (License: MIT)',
+            asOf: '2026-10-15',
           },
           {
-            url: 'https://automationatlas.io/tools/langflow/',
-            label: 'Automation Atlas: Langflow pricing summary',
-            asOf: '2026-07-02',
+            url: 'https://docs.datastax.com/en/astra-db-serverless/release-notes.html#datastax-langflow-removal',
+            label: 'Astra release notes: DataStax Langflow removal (April 9, 2026)',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://www.ibm.com/products/langflow',
+            label: 'IBM Langflow (Editions)',
+            asOf: '2026-10-15',
           },
         ],
       },
       entryPaidPlan: {
         value:
-          "Unknown: the exact entry paid-plan price and inclusions aren't confirmed on Langflow's own official pricing page. Third-party summaries cite a cloud paid tier starting around $25 per month.",
-        detail: 'Not confirmed against an official Langflow source.',
-        shortValue: 'Unverified; third parties cite roughly $25/month',
-        confidence: 'unknown',
-        sources: [],
+          'None published: there is no Langflow-branded paid plan. The paid path IBM lists is IBM Elite Support for Langflow, aimed at enterprises needing SLAs and support for Langflow OSS, with no public price',
+        shortValue: 'No published paid plan',
+        confidence: 'estimated',
+        sources: [
+          {
+            url: 'https://www.ibm.com/products/langflow',
+            label: 'IBM Langflow (Editions)',
+            asOf: '2026-10-15',
+          },
+        ],
       },
       freeTier: {
         value:
-          'Yes: the open-source core is free to self-host, with no usage caps beyond your own infrastructure. Langflow Cloud reportedly offers a free account tier before infrastructure and API costs apply.',
-        detail: 'Exact cloud free-tier limits not officially confirmed.',
-        shortValue: 'Yes, free self-hosted core plus a free cloud tier',
+          'Yes: the MIT-licensed software is free to self-host or to run as Langflow Desktop. A hosted free tier can no longer be confirmed, since DataStax removed its hosted Langflow from Astra on April 9, 2026',
+        shortValue: 'Free self-hosted and Desktop; no confirmed hosted tier',
         confidence: 'estimated',
         sources: [
           {
-            url: 'https://www.lindy.ai/blog/langflow-pricing',
-            label: 'Lindy: Langflow Pricing',
-            asOf: '2026-07-02',
+            url: 'https://www.langflow.org',
+            label: 'Langflow homepage',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://docs.datastax.com/en/astra-db-serverless/release-notes.html#datastax-langflow-removal',
+            label: 'Astra release notes: DataStax Langflow removal',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -683,7 +720,7 @@ export const langflowProfile: CompetitorProfile = {
           {
             url: 'https://docs.langflow.org/agents',
             label: 'Langflow Docs: Use Langflow agents',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -948,9 +985,9 @@ export const langflowProfile: CompetitorProfile = {
       },
       unattendedExecution: {
         value:
-          'Partial: when Langflow is deployed as a server, self-hosted via Docker/Kubernetes or on Langflow Cloud, triggered runs (webhook, API call, or external cron/Airflow calling the API) execute on that server with no dependency on any particular client device staying open. But Langflow can also be run as a desktop app, and a flow triggered through that installation depends on the desktop app process itself staying running on that machine, since there is no separate always-on server component in that deployment mode.',
+          'Partial: when Langflow is deployed as a server, self-hosted via Docker/Kubernetes, triggered runs (webhook, API call, or external cron/Airflow calling the API) execute on that server with no dependency on any particular client device staying open. But Langflow can also be run as a desktop app, and a flow triggered through that installation depends on the desktop app process itself staying running on that machine, since there is no separate always-on server component in that deployment mode.',
         detail:
-          'The dependency is on the chosen deployment mode: a Docker/Kubernetes/Cloud deployment behaves like Sim (server-side, client-independent), while the desktop app is a local process that must stay running to serve triggers.',
+          'The dependency is on the chosen deployment mode: a Docker/Kubernetes deployment behaves like Sim (server-side, client-independent), while the desktop app is a local process that must stay running to serve triggers.',
         shortValue: 'Yes if server-deployed; desktop app requires that app to stay running',
         confidence: 'estimated',
         sources: [
diff --git a/apps/sim/lib/compare/data/competitors/n8n.ts b/apps/sim/lib/compare/data/competitors/n8n.ts
index 441e002b667..f8963e0fc1a 100644
--- a/apps/sim/lib/compare/data/competitors/n8n.ts
+++ b/apps/sim/lib/compare/data/competitors/n8n.ts
@@ -30,6 +30,27 @@ export const n8nProfile: CompetitorProfile = {
   },
   oneLiner:
     'n8n is a fair-code workflow automation platform combining a visual, node-based builder with custom code and built-in AI/agent nodes, available as a self-hosted or cloud-hosted product.',
+  leadAnswer: [
+    'n8n is a fair-code workflow automation platform with a visual node-based builder, custom code nodes, and built-in AI Agent nodes, available as a free self-hosted Community Edition or on n8n Cloud. Sim is an open-source AI workspace with an Apache 2.0-licensed core, where teams build, deploy, and manage AI agents visually, conversationally, or with code, on Sim Cloud or self-hosted. Choose n8n when you want execution-based pricing with unlimited users on every plan and dataset-based evaluations for AI workflows. Choose Sim when you want a permissively licensed core, a built-in hybrid-search knowledge base that syncs external sources, or live multiplayer editing of the same canvas.',
+  ],
+  faqs: [
+    {
+      question:
+        'n8n is fair-code with license restrictions. Is there a permissively licensed alternative?',
+      answer:
+        "Sim's core is licensed under Apache 2.0, a permissive OSI-approved license, while n8n's Sustainable Use License is not OSI open source. n8n's license permits use or modification only for internal business purposes or for non-commercial or personal use, and allows distribution only free of charge for non-commercial purposes. Both products keep enterprise features under a separate paid license: files marked '.ee.' in n8n, and the enterprise directory in Sim. Sim's Apache 2.0 core has no field-of-use limits and can be self-hosted with Docker Compose or Kubernetes.",
+    },
+    {
+      question: "What is a good n8n alternative for teams that don't want to self-host?",
+      answer:
+        "Sim Cloud is a managed option that includes a Free plan, while n8n Cloud offers a trial with no credit card but no ongoing free cloud plan. Both are fully managed, so neither requires you to operate infrastructure. n8n's Business plan is currently available only for self-hosted n8n, so managed n8n customers choose among the Starter, Pro, and Enterprise cloud plans.",
+    },
+    {
+      question: 'What does Sim do differently from n8n for building AI agents?',
+      answer:
+        "Sim builds a knowledge base into the workspace, while n8n assembles retrieval from separate nodes. n8n provides an AI Agent node that calls tools, including MCP tools, a RAG pipeline built from loaders, embeddings, and external vector stores such as Pinecone, Qdrant, or PGVector, and an Evaluations feature that scores workflows against test datasets. Sim provides agent blocks, a knowledge base with hybrid vector and full-text search plus connectors that continuously sync sources such as Google Drive and Confluence, and Chat and Copilot surfaces that build and edit workflows from natural language. Sim's Evaluator and Guardrails blocks score individual calls rather than running a batch dataset suite.",
+    },
+  ],
   standoutFeatures: [
     {
       title: 'Unlimited users on every plan, including the entry tier',
@@ -161,7 +182,7 @@ export const n8nProfile: CompetitorProfile = {
           {
             url: 'https://docs.n8n.io/choose-how-to-use-n8n.md',
             label: 'n8n docs: Choose how to use n8n',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -210,7 +231,7 @@ export const n8nProfile: CompetitorProfile = {
           {
             url: 'https://raw.githubusercontent.com/n8n-io/n8n/master/LICENSE.md',
             label: 'n8n LICENSE.md',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -814,51 +835,73 @@ export const n8nProfile: CompetitorProfile = {
       pricingModel: {
         value: 'Per-workflow-execution pricing tiers, unlimited users at every tier',
         detail:
-          "n8n's pricing page states workflows are billed by monthly execution count. A workflow that runs start-to-finish counts as one execution regardless of the number of steps or nodes. Unlimited users are included at every paid tier.",
+          "n8n's pricing page states that an execution is a single run of an entire workflow, regardless of how many steps it has or how much data it processes, and that all plans include unlimited users and workflows. The Business plan is currently only available for self-hosted n8n.",
         shortValue: 'Billed by monthly workflow executions',
         confidence: 'verified',
-        sources: [{ url: 'https://n8n.io/pricing/', label: 'n8n Pricing', asOf: '2026-07-02' }],
+        sources: [
+          {
+            url: 'https://n8n.io/pricing/',
+            label: 'n8n Pricing',
+            asOf: '2026-10-15',
+          },
+        ],
       },
       entryPaidPlan: {
         value: 'Starter plan: €20/month (billed annually), 2,500 executions/month, cloud-hosted',
         detail:
-          'Starter includes 2,500 workflow executions per month, 5 concurrent executions, 1 shared project, unlimited users, 2,300 AI credits, and forum support.',
+          'Starter includes 2,500 workflow executions per month, 5 concurrent executions, 1 shared project, unlimited users and workflows, 1,600 Assistant credits per month, and forum support.',
         shortValue: '€20/month, 2,500 executions',
         confidence: 'verified',
-        sources: [{ url: 'https://n8n.io/pricing/', label: 'n8n Pricing', asOf: '2026-07-08' }],
+        sources: [
+          {
+            url: 'https://n8n.io/pricing/',
+            label: 'n8n Pricing',
+            asOf: '2026-10-15',
+          },
+        ],
       },
       freeTier: {
-        value: 'Yes: free self-hosted Community Edition, plus a free cloud trial (no credit card)',
+        value:
+          'Yes: free self-hosted Community Edition, plus a free n8n Cloud trial (no credit card); no free cloud plan',
         detail:
-          "The Community Edition is a free, self-hosted version of n8n runnable on a user's own infrastructure. Separately, n8n Cloud offers a free trial of the Starter/Pro plans without requiring a credit card.",
+          'The Community Edition is a free, self-hosted version of n8n with almost the complete feature set. n8n Cloud offers a trial with 1,000 executions and 5 concurrent executions with no credit card required; there is no ongoing free cloud plan.',
         shortValue: 'Free self-hosted edition and cloud trial',
         confidence: 'verified',
         sources: [
           {
             url: 'https://docs.n8n.io/choose-how-to-use-n8n.md',
             label: 'n8n docs: Choose how to use n8n',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://n8n.io/pricing/',
+            label: 'n8n Pricing',
+            asOf: '2026-10-15',
           },
-          { url: 'https://n8n.io/pricing/', label: 'n8n Pricing', asOf: '2026-07-02' },
         ],
       },
       byok: {
         value:
-          'De facto yes: Chat Model nodes require users\' own provider API credentials, though n8n does not name this "BYOK"',
+          'Yes: self-hosted n8n is BYOK with no credit limits; n8n Cloud Starter and Pro also offer prepaid Gateway credits to use supported models without your own API keys',
         detail:
-          "n8n's OpenAI and Anthropic credential docs both walk users through generating an API key in the provider's own console and entering it as the node credential; no n8n-hosted key is supplied for these Chat Model nodes. Separately, n8n's pricing page describes plan-included 'AI credits' (2,300 on Starter, up to 13,700+ on higher tiers) for n8n's own in-app AI Assistant feature, which is distinct from the provider credentials Chat Model nodes require. n8n does not name a bring-your-own-API-key policy, but requiring each provider's own key for Chat Model nodes makes BYOK the de facto default for workflow-level LLM calls.",
-        shortValue: 'De facto via provider API keys, not named',
-        confidence: 'estimated',
+          "n8n's pricing page states that on self-hosted n8n you bring your own key (BYOK), so no credit limits apply. On n8n Cloud Starter and Pro, Chat Model nodes can use either your own provider credential or Gateway credits, a prepaid balance that runs supported AI models and services without provider accounts; Gateway credits are not available on Cloud Enterprise or self-hosted n8n. Assistant credits are a separate allowance for n8n's in-app Assistant.",
+        shortValue: 'BYOK; Cloud also offers keyless Gateway credits',
+        confidence: 'verified',
         sources: [
           {
-            url: 'https://docs.n8n.io/integrations/builtin/credentials/openai',
-            label: 'n8n docs: OpenAI credentials',
-            asOf: '2026-07-08',
+            url: 'https://n8n.io/pricing/',
+            label: 'n8n Pricing',
+            asOf: '2026-10-15',
           },
           {
-            url: 'https://docs.n8n.io/integrations/builtin/credentials/anthropic',
-            label: 'n8n docs: Anthropic credentials',
-            asOf: '2026-07-08',
+            url: 'https://docs.n8n.io/deploy/use-n8n-cloud/gateway-credits.md',
+            label: 'n8n docs: Gateway credits',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://docs.n8n.io/integrations/builtin/credentials/openai',
+            label: 'n8n docs: OpenAI credentials',
+            asOf: '2026-10-15',
           },
         ],
       },
diff --git a/apps/sim/lib/compare/data/competitors/openclaw.ts b/apps/sim/lib/compare/data/competitors/openclaw.ts
index ad3b531b36b..b1757dfc642 100644
--- a/apps/sim/lib/compare/data/competitors/openclaw.ts
+++ b/apps/sim/lib/compare/data/competitors/openclaw.ts
@@ -16,6 +16,27 @@ export const openClawProfile: CompetitorProfile = {
   },
   oneLiner:
     "OpenClaw is a free, open-source, self-hosted personal AI agent that runs on a user's own machine or server and connects to messaging platforms (WhatsApp, Telegram, Slack, Discord, Signal, iMessage, Microsoft Teams, and others) as its primary interface, extensible via a Skills plugin system and the ClawHub marketplace. It is not a visual workflow/automation builder like Sim, n8n, or Power Automate.",
+  leadAnswer: [
+    'OpenClaw is a free, MIT-licensed personal AI agent that runs as a single self-hosted Gateway process on your own machine or server and is operated through chat apps such as WhatsApp, Telegram, Slack, and Discord. Sim is an open-source AI workspace where teams build, deploy, and manage agents on a visual canvas, in natural language, or with code, on Sim Cloud or a self-hosted Docker or Kubernetes deployment. Choose OpenClaw for a single-operator assistant you message from your existing chat apps, using your own model keys and keeping state on your own hardware. Choose Sim when a team needs shared workspaces with role-based permissions, per-block execution traces, and scheduled or webhook-triggered runs that execute server-side without depending on one machine staying on.',
+  ],
+  faqs: [
+    {
+      question:
+        'What is the best alternative to OpenClaw for teams that need production reliability?',
+      answer:
+        'Sim is an OpenClaw alternative where scheduled, webhook, and chat-triggered runs execute as background jobs on the Sim server, whether Sim Cloud or your own self-hosted deployment, so no personal machine has to stay on. OpenClaw automations run inside its self-hosted Gateway process, and its docs state the Gateway must be running for schedules to fire. Sim also records a per-block trace of every run (duration, cost, tokens) and can alert Slack, email, or a webhook on failures or cost and latency spikes. OpenClaw keeps automation run history for 7 days and, by default, sends a failure alert after 2 consecutive failures.',
+    },
+    {
+      question: 'What is a good OpenClaw alternative for building production AI agents?',
+      answer:
+        'Sim is an OpenClaw alternative for teams that build agents as workflows and publish them as REST APIs, MCP servers, scheduled jobs, or chat interfaces. OpenClaw is a personal assistant configured through a JSON file and Markdown Skills and operated by messaging it, with no visual builder. In Sim, any block can route to an error branch so one failing step does not halt the run, and on the Enterprise plan a workspace can be forked into dev, QA, and prod copies and promoted between them.',
+    },
+    {
+      question: 'Sim vs OpenClaw for building AI agents: which should I use?',
+      answer:
+        "Use OpenClaw if you want one personal agent that you message from WhatsApp, Telegram, Slack, Discord, or another chat app, running on your own hardware with your own model keys. Use Sim if several people need to build and run agents together: Sim has admin, write, and read workspace permissions and live multiplayer editing of the same workflow, while OpenClaw's security docs assume one trusted boundary per gateway and state it is not a hostile multi-tenant security boundary. OpenClaw is free under the MIT license; Sim's core is Apache 2.0, with a Free plan and a Pro plan at $25 per user per month.",
+    },
+  ],
   standoutFeatures: [
     {
       title: '22+ messaging channels as the primary interface',
@@ -197,14 +218,19 @@ export const openClawProfile: CompetitorProfile = {
         value:
           "Yes: self-hosting is the only deployment model. OpenClaw runs as a single Gateway process on the user's own machine or server. There is no OpenClaw-operated hosted/SaaS version.",
         detail:
-          'Docs describe the Gateway as running locally and being "the single source of truth for sessions, routing, and channel connections," with a local workspace at ~/.openclaw/workspace.',
+          'The docs say you "run a single Gateway process on your own machine (or a server)" with "No hosted service in the middle", and the homepage says "State lives on your machine, not a vendor cloud." OpenClaw Enterprise (announced September 2026) is also self-hosted only, deployed with docker-compose or Kubernetes on the organization\'s own infrastructure.',
         shortValue: 'Yes, self-hosting only, no vendor-hosted SaaS option',
         confidence: 'verified',
         sources: [
           {
             url: 'https://docs.openclaw.ai/',
             label: 'OpenClaw Docs home',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://openclaw.ai/blog/openclaw-enterprise/',
+            label: 'OpenClaw blog: OpenClaw Enterprise',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -242,19 +268,24 @@ export const openClawProfile: CompetitorProfile = {
         value:
           'MIT License (permissive open source), stewarded by the independent, non-profit OpenClaw Foundation, not a single vendor company',
         detail:
-          "The GitHub repository's LICENSE file confirms MIT licensing. Governance passed from creator Peter Steinberger to a community-elected Foundation board after he joined OpenAI in February 2026. OpenAI is a Foundation sponsor (inference support and Codex Security scanning) but does not own the project.",
+          'The LICENSE file reads "MIT License, Copyright (c) 2026 OpenClaw Foundation." The homepage describes the Foundation as "an independent US 501(c)(3) non-profit" that keeps "the whole product MIT licensed". Its institutional donors include Microsoft, NVIDIA, OpenAI, Red Hat, and the University of Michigan.',
         shortValue: 'MIT license, non-profit Foundation governance',
         confidence: 'verified',
         sources: [
           {
             url: 'https://github.com/openclaw/openclaw/blob/main/LICENSE',
             label: 'openclaw/openclaw LICENSE file',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
           {
-            url: 'https://openclaw.ai/ecosystem/',
-            label: 'OpenClaw Ecosystem page',
-            asOf: '2026-07-02',
+            url: 'https://openclaw.ai/',
+            label: 'OpenClaw homepage',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://openclaw.org/donors',
+            label: 'OpenClaw Foundation donors',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -763,7 +794,7 @@ export const openClawProfile: CompetitorProfile = {
           {
             url: 'https://github.com/openclaw/openclaw/blob/main/LICENSE',
             label: 'openclaw/openclaw LICENSE file',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -778,7 +809,7 @@ export const openClawProfile: CompetitorProfile = {
           {
             url: 'https://github.com/openclaw/openclaw/blob/main/LICENSE',
             label: 'openclaw/openclaw LICENSE file',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -793,22 +824,27 @@ export const openClawProfile: CompetitorProfile = {
           {
             url: 'https://github.com/openclaw/openclaw/blob/main/LICENSE',
             label: 'openclaw/openclaw LICENSE file',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
       byok: {
         value:
-          'Yes, and mandatory: OpenClaw requires the operator to supply their own API credentials/OAuth login for whichever model provider(s) they configure (Anthropic, OpenAI, Google, or any OpenAI-compatible endpoint); there is no OpenClaw-hosted model access.',
+          'Yes, and it is the only option: model access always comes from the operator, via their own provider API key, a provider OAuth login (e.g. OpenAI ChatGPT/Codex), a third-party gateway such as OpenRouter, or a local runtime (Ollama, LM Studio, vLLM, llama.cpp). OpenClaw provides no hosted model access of its own.',
         detail:
-          'Onboarding documentation walks through provider-specific auth flows (e.g. `openclaw models auth paste-token --provider anthropic`, `openclaw models auth login --provider openai-codex`). BYOK is the only supported model-access model.',
-        shortValue: 'Yes, mandatory; no OpenClaw-hosted model access',
+          'The model-providers docs cover multiple API keys with rotation under Settings -> Models, provider OAuth login, and onboarding commands such as `openclaw onboard --auth-choice opencode-zen`. The homepage states "No subscription. No hosted tier. No token."',
+        shortValue: 'Yes, only option; own keys, OAuth, gateway, or local model',
         confidence: 'verified',
         sources: [
           {
             url: 'https://docs.openclaw.ai/concepts/model-providers',
             label: 'OpenClaw Docs: Model providers',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://openclaw.ai/',
+            label: 'OpenClaw homepage',
+            asOf: '2026-10-15',
           },
         ],
       },
diff --git a/apps/sim/lib/compare/data/competitors/pipedream.ts b/apps/sim/lib/compare/data/competitors/pipedream.ts
index ebfce7c7a49..c127f49ef7c 100644
--- a/apps/sim/lib/compare/data/competitors/pipedream.ts
+++ b/apps/sim/lib/compare/data/competitors/pipedream.ts
@@ -18,7 +18,27 @@ export const pipedreamProfile: CompetitorProfile = {
     asOf: '2026-07-02',
   },
   oneLiner:
-    'Pipedream is a cloud integration platform, now owned by Workday (acquired Nov 2025), that connects 3,000+ APIs through low-code workflows or custom Node.js/Python/Go code, and exposes those integrations to AI agents as tools through a hosted MCP server.',
+    'Pipedream is a cloud integration platform, now owned by Workday (acquired Nov 2025), whose Connect product gives apps and AI agents managed authentication and prebuilt tools across 3,000+ APIs through SDKs, a REST API, and a hosted MCP server; its Workflows automation product no longer accepts signups and shuts down on March 31, 2027.',
+  leadAnswer: [
+    'Pipedream is an integration layer for AI agents: its Connect product gives developers managed authentication and prebuilt tools across 3,000+ APIs through SDKs, a REST API, and an MCP server, while its Workflows automation product is in maintenance mode and shuts down on March 31, 2027. Sim is an open-source AI workspace with an Apache 2.0-licensed core, where teams build, deploy, and manage AI agents and automations visually, conversationally, or with code, on Sim Cloud or self-hosted. Choose Pipedream Connect when you are a developer embedding customer-facing integrations or tools into your own app or agent. Choose Sim when you want to build and run the automations and agents themselves on a visual canvas, including self-hosted.',
+  ],
+  faqs: [
+    {
+      question: 'What is a Pipedream alternative with a visual builder for non-developers?',
+      answer:
+        "Sim offers a visual drag-and-drop canvas and a natural-language Chat surface that builds and edits workflows from plain-language requests. Pipedream's visual builder belongs to its Workflows product, which no longer accepts signups or subscriptions and shuts down on March 31, 2027. Pipedream's ongoing product, Connect, is delivered as SDKs, a REST API, and an MCP server for developers adding integrations to their own apps and agents.",
+    },
+    {
+      question: 'How does Sim compare to Pipedream for building automations?',
+      answer:
+        'Sim is built to create and run automations and agents, while Pipedream now centers on Connect, an integration layer that supplies tools and managed authentication to apps and agents you build yourself. Sim workflows run from webhook, schedule, chat, REST API, and app-event triggers, and can include code blocks for custom logic. Pipedream Workflows supported low-code steps plus custom Node.js, Python, Bash, or Go code, but it is in maintenance mode with no new features and ends on March 31, 2027.',
+    },
+    {
+      question: 'Is Pipedream Workflows shutting down?',
+      answer:
+        'Yes. Pipedream Workflows shuts down on March 31, 2027, and all Workflows data, including stored credentials and OAuth tokens, is deleted by April 30, 2027; Pipedream Connect is not affected. Pipedream provides an export tool that downloads workflow structure as JSON, one project at a time. Sim, with an Apache 2.0-licensed core, can run those automations on Sim Cloud or self-hosted, though workflows need to be rebuilt in Sim rather than imported.',
+    },
+  ],
   standoutFeatures: [
     {
       title: 'Hosted MCP server covering thousands of apps',
@@ -34,9 +54,14 @@ export const pipedreamProfile: CompetitorProfile = {
     {
       title: 'Code-first escape hatch alongside no-code builder',
       description:
-        "Any step in a Pipedream workflow can be replaced with custom Node.js, Python, Bash, or Go code, and pre-built actions can be used as no-code building blocks or 'scaffolded' into code you customize.",
-      shortDescription: 'Every workflow step can drop into custom code in four languages.',
-      source: { url: 'https://pipedream.com/docs', label: 'Pipedream Docs', asOf: '2026-07-02' },
+        "Any step in a Pipedream workflow can be replaced with custom Node.js, Python, Bash, or Go code, and pre-built actions can be used as no-code building blocks or 'scaffolded' into code you customize. This is part of Pipedream Workflows, which shuts down on March 31, 2027.",
+      shortDescription:
+        'Workflow steps drop into custom code in four languages (Workflows, ending 2027).',
+      source: {
+        url: 'https://pipedream.com/docs/workflows',
+        label: 'Pipedream Docs: Workflows',
+        asOf: '2026-10-15',
+      },
     },
     {
       title: 'Source-available component registry on GitHub',
@@ -51,6 +76,17 @@ export const pipedreamProfile: CompetitorProfile = {
     },
   ],
   limitations: [
+    {
+      title: 'Workflows product is shutting down',
+      description:
+        'Pipedream Workflows is in maintenance mode, no longer accepts signups or subscriptions, and shuts down on March 31, 2027. All Workflows data, including stored credentials and OAuth tokens, is deleted by April 30, 2027; an export tool saves workflow structure as JSON, one project at a time. Pipedream Connect is not affected.',
+      shortDescription: 'Workflows shuts down on March 31, 2027; Connect continues.',
+      source: {
+        url: 'https://pipedream.com/docs/workflows',
+        label: 'Pipedream Docs: Workflows',
+        asOf: '2026-10-15',
+      },
+    },
     {
       title: 'Not self-hostable',
       description:
@@ -65,8 +101,8 @@ export const pipedreamProfile: CompetitorProfile = {
     {
       title: 'Proprietary source-available license, not open source',
       description:
-        "The GitHub repository is licensed under the 'Pipedream Source Available License Version 1.0,' which explicitly prohibits using the code to run a competing SaaS/PaaS/IaaS offering. This is not an OSI-approved open-source license.",
-      shortDescription: "The component repo's license bars running a competing service.",
+        "The GitHub repository is licensed under the 'Pipedream Source Available License Version 1.0,' whose Excluded Purpose covers any commercial use of the code, including running a competing SaaS/PaaS/IaaS offering. This is not an OSI-approved open-source license.",
+      shortDescription: "The component repo's license excludes commercial use.",
       source: {
         url: 'https://github.com/PipedreamHQ/pipedream/blob/master/LICENSE',
         label: 'GitHub: LICENSE file',
@@ -126,12 +162,12 @@ export const pipedreamProfile: CompetitorProfile = {
           {
             url: 'https://github.com/PipedreamHQ/pipedream/issues/954',
             label: 'GitHub Issue #954',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
           {
             url: 'https://github.com/PipedreamHQ/pipedream',
             label: 'GitHub: PipedreamHQ/pipedream repo description',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -172,14 +208,14 @@ export const pipedreamProfile: CompetitorProfile = {
         value:
           'Proprietary (Pipedream Source Available License v1.0) for the GitHub component registry; hosted platform is closed-source SaaS',
         detail:
-          'Not an OSI-approved open-source license. It bars using the code to run a competing SaaS/PaaS/IaaS.',
+          'Not an OSI-approved open-source license. Its Excluded Purpose covers any commercial use of the software, including running a SaaS, PaaS, IaaS, or other online service that competes with Pipedream.',
         shortValue: 'Proprietary source-available registry license',
         confidence: 'verified',
         sources: [
           {
             url: 'https://github.com/PipedreamHQ/pipedream/blob/master/LICENSE',
             label: 'GitHub: LICENSE file',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -681,51 +717,65 @@ export const pipedreamProfile: CompetitorProfile = {
     pricing: {
       pricingModel: {
         value:
-          'Credit-based compute pricing (per-execution-time credits) plus separate Connect usage/end-user pricing',
+          'Credit-based Connect usage (1 credit per 30 seconds of compute) plus a per-external-user fee; legacy Workflows credit pricing ends with the product on March 31, 2027',
         detail:
-          '1 credit = 30 seconds of workflow compute at 256MB memory; credit burn rate scales with memory allocation. Connect (embedding Pipedream in your own app) bills separately on API usage (actions/tool calls/trigger emits) and number of connected end users.',
-        shortValue: 'Credit-based compute; separate Connect usage pricing',
+          "Pipedream's pricing page now covers Connect only: credits are consumed by action runs, MCP tool calls, Connect proxy requests, and deployed-trigger emits at 1 credit per 30 seconds of compute, and plans also bill per unique external user who connects an account. Pipedream Workflows used the same 30-second credit at 256MB memory, but Workflows no longer accepts signups or subscriptions and shuts down on March 31, 2027.",
+        shortValue: 'Connect credits plus per-user fee',
         confidence: 'verified',
         sources: [
+          {
+            url: 'https://pipedream.com/pricing',
+            label: 'Pipedream Pricing',
+            asOf: '2026-10-15',
+          },
           {
             url: 'https://pipedream.com/docs/pricing',
             label: 'Pipedream Docs: Plans and Pricing',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
+          },
+          {
+            url: 'https://pipedream.com/docs/workflows',
+            label: 'Pipedream Docs: Workflows',
+            asOf: '2026-10-15',
           },
         ],
       },
       entryPaidPlan: {
         value:
-          'Not publicly listed; third-party estimates range roughly $29–$45/mo for the entry paid tier',
+          'Startup plan: $99/month billed annually ($150 billed monthly), 10,000 usage credits and 100 external users included',
         detail:
-          "Pipedream's own pricing page is JavaScript-rendered and not directly verifiable via static fetch. Third-party sources report conflicting numbers for the entry paid tier, roughly $29/mo to $45/mo for around 2,000 credits/month, but the exact current price is unconfirmed from a primary source.",
-        shortValue: '~$29–$45/mo (unconfirmed)',
-        confidence: 'estimated',
+          'Startup is the entry paid plan and is required to run Connect in production. It includes 10,000 usage credits per month (then $0.012 each) and 100 external users (then $2 per user per month), with email support. Pipedream Workflows subscriptions are no longer sold.',
+        shortValue: '$99/month annual, 10,000 credits',
+        confidence: 'verified',
         sources: [
           {
             url: 'https://pipedream.com/pricing',
-            label:
-              'Pipedream Pricing page (official, JS-rendered, not independently verifiable via fetch)',
-            asOf: '2026-07-02',
+            label: 'Pipedream Pricing',
+            asOf: '2026-10-15',
           },
           {
-            url: 'https://automationatlas.io/answers/pipedream-pricing-explained-2026/',
-            label: 'Automation Atlas: Pipedream Pricing Explained 2026 (third-party)',
-            asOf: '2026-07-02',
+            url: 'https://pipedream.com/docs/workflows',
+            label: 'Pipedream Docs: Workflows',
+            asOf: '2026-10-15',
           },
         ],
       },
       freeTier: {
-        value: 'Yes: free workspace with a daily credit limit',
+        value: 'Yes: free workspace for development only, with a daily credit limit',
         detail:
-          'Free workspaces get a daily limit of free credits (cannot be exceeded/rolled over), a capped number of active workflows and connected accounts, community-only support, and Connect development-environment access only. Developing/testing a workflow with test events in the builder is always free, and public-registry event source triggers are free.',
-        shortValue: 'Free tier with daily credit cap',
+          'The Free plan ($0, no credit card) includes every feature in development, unlimited team members, and community support, with a daily credit limit that cannot be exceeded and a limited number of connected accounts. Serving real external users in production requires the paid Startup plan.',
+        shortValue: 'Free in development, daily credit cap',
         confidence: 'verified',
         sources: [
+          {
+            url: 'https://pipedream.com/pricing',
+            label: 'Pipedream Pricing',
+            asOf: '2026-10-15',
+          },
           {
             url: 'https://pipedream.com/docs/pricing',
             label: 'Pipedream Docs: Plans and Pricing',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
diff --git a/apps/sim/lib/compare/data/competitors/vellum.ts b/apps/sim/lib/compare/data/competitors/vellum.ts
index 1b9046b0dfc..475e036e7c3 100644
--- a/apps/sim/lib/compare/data/competitors/vellum.ts
+++ b/apps/sim/lib/compare/data/competitors/vellum.ts
@@ -16,6 +16,26 @@ export const vellumProfile: CompetitorProfile = {
   },
   oneLiner:
     'Vellum is an enterprise AI development platform for building, evaluating, and deploying LLM prompts, workflows, and agents.',
+  leadAnswer: [
+    "Vellum's enterprise platform is a hosted AI development product for building, evaluating, and deploying LLM prompts, workflows, and agents through a visual builder, a code SDK, or natural language, with self-hosted and VPC installs for enterprises; its public website now leads with a separate consumer assistant, and the platform's pricing is not published. Sim is an open-source AI workspace with an Apache 2.0-licensed core for building, deploying, and managing agents visually, conversationally, or with code, with a Free plan, a $25 per user/month Pro plan, and self-hosting via Docker Compose or Kubernetes. Choose Vellum when test-suite evaluations, HIPAA coverage with a signed BAA, or a vendor-managed single-tenant VPC are requirements. Choose Sim when you want published self-serve pricing, an open-source core, or live multiplayer editing of the same workflow.",
+  ],
+  faqs: [
+    {
+      question: 'Which is easier for non-engineers to use, Sim or Vellum?',
+      answer:
+        "Both offer a natural-language path: Vellum turns a plain-language goal into a working agent, and Sim's Chat and in-editor Copilot build and edit workflows from natural-language requests on top of a visual canvas. The practical difference is access: Sim has a Free plan and a published $25 per user/month Pro plan, while Vellum's enterprise platform publishes no pricing and its self-hosted option is arranged through a sales demo.",
+    },
+    {
+      question: 'How do Sim and Vellum compare for building and deploying agents?',
+      answer:
+        'Both build agents with a visual builder, code, or natural language, and both deploy to managed cloud or self-hosted infrastructure; Vellum adds a vendor-managed VPC install on AWS, Azure, or GCP, while Sim self-hosts with Docker Compose or Kubernetes. For promotion, Vellum offers Dev, Staging, and Prod environments with one-click promotion, and Sim (on the Enterprise plan) forks a whole workspace into a dev/qa/prod-style child, diffs it, and requires credential remapping before each promote. Sim also deploys a workflow as a public chat interface or as a tool on an MCP server.',
+    },
+    {
+      question: 'Is Vellum still an enterprise agent platform or a personal assistant?',
+      answer:
+        "Both exist under one brand: vellum.ai, including its pricing page, now presents a consumer 'Personal Intelligence' assistant with $30 to $200 monthly packages, while docs.vellum.ai still documents the enterprise workflow and evaluation platform. The most recent entries in those platform docs are a February 2026 changelog and a self-hosted release dated February 6, 2026. Sim is a single product, an AI workspace for building and deploying agents, with its plans published on its own pricing page.",
+    },
+  ],
   standoutFeatures: [
     {
       title: 'HIPAA compliance with a signable BAA',
@@ -54,15 +74,15 @@ export const vellumProfile: CompetitorProfile = {
       },
     },
     {
-      title: 'Enterprise BYOK policy no longer verifiable',
+      title: 'Enterprise pricing no longer published',
       description:
-        "Vellum's pricing page has been replaced by a consumer 'Personal Intelligence' pricing model (subscription plus pay-as-you-go credits); the original enterprise LLM-cost-pass-through pricing this claim describes, including any bring-your-own-API-key policy, is no longer published at this URL.",
+        "Vellum's pricing page now shows a consumer 'Personal Intelligence' product (subscription plus pay-as-you-go credits). The enterprise platform's pricing, including how your own provider API keys affect billing, is no longer published.",
       shortDescription:
-        'Pricing page now shows a different consumer product; enterprise BYOK policy unconfirmed.',
+        'Pricing page now shows a different consumer product; enterprise pricing unpublished.',
       source: {
         url: 'https://www.vellum.ai/pricing',
         label: 'Vellum Pricing (now shows the consumer product)',
-        asOf: '2026-07-08',
+        asOf: '2026-10-15',
       },
     },
     {
@@ -122,19 +142,19 @@ export const vellumProfile: CompetitorProfile = {
       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.",
+          "Vellum's self-hosting docs describe running 'the complete Vellum platform within your own infrastructure', including air-gapped environments, available through a sales demo. A 2024 announcement describes VPC installs on AWS, Azure, and GCP supported via Replicated. The most recent self-hosted release listed is v0.3.44 (February 6, 2026).",
         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',
+            asOf: '2026-10-15',
           },
           {
             url: 'https://www.vellum.ai/blog/announcing-vellum-vpc',
             label: 'Announcing Vellum VPC',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -166,14 +186,14 @@ export const vellumProfile: CompetitorProfile = {
         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.',
+          'github.com/vellum-ai/vellum-assistant is MIT-licensed (1,400+ 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',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -697,19 +717,19 @@ export const vellumProfile: CompetitorProfile = {
         value:
           "Not publicly listed for the B2B enterprise platform: Vellum's current pricing page has been fully replaced by the unrelated consumer 'Personal Intelligence' product's plans. A September 2025 third-party pricing analysis, published before that switch, described the enterprise platform as execution-credit-based with per-tier seat caps (Free, Pro, Enterprise) rather than the prepaid-credit model now shown.",
         detail:
-          "Current pricing pages (vellum.ai/pricing, vellum.ai/docs/pricing) describe the consumer 'Personal Intelligence' product's plans (Base/Free and Pro $50/mo tiers with configurable vCPU/RAM/storage add-ons), not the enterprise workflow platform. The last third-party description of the enterprise platform's model itself states Vellum 'does not publicly list pricing details on its website,' so the figures below are third-party estimates, not Vellum-published prices.",
+          "Current pricing pages (vellum.ai/pricing, vellum.ai/docs/pricing) describe the consumer 'Personal Intelligence' assistant: a free Base plan and Pro packages at $30, $100, and $200 per month or a Custom configuration from $50/month. None of this covers the enterprise workflow platform. The last third-party description of the enterprise platform (ZenML, September 2025) states Vellum 'does not publicly list pricing details on its website,' so the figures below are third-party estimates, not Vellum-published prices.",
         shortValue: 'Not publicly listed; third-party analysis describes credit-based tiers',
         confidence: 'unknown',
         sources: [
           {
             url: 'https://www.zenml.io/blog/vellum-ai-pricing',
             label: 'Vellum AI Pricing: ZenML Blog',
-            asOf: '2026-07-04',
+            asOf: '2026-10-15',
           },
           {
             url: 'https://www.vellum.ai/pricing',
             label: 'Vellum Pricing (now shows the consumer product)',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -717,14 +737,14 @@ export const vellumProfile: CompetitorProfile = {
         value:
           'Unconfirmed: a third-party analysis reports a Pro tier around $500/month for the enterprise platform, but Vellum does not publish this figure itself',
         detail:
-          "The cited third-party breakdown describes Pro at roughly $500/month with 5,000 prompt executions/day, 250 workflow executions/day, RBAC, and monitoring integrations, still capped at 5 users; Enterprise tiers above that are custom/'Contact us' pricing. None of this is confirmed on Vellum's own site, which currently shows only the unrelated consumer product's $50/mo Pro plan.",
+          "The cited third-party breakdown describes Pro at roughly $500/month with 5,000 prompt executions/day and 250 workflow executions/day; Enterprise tiers above that are custom pricing. None of this is confirmed on Vellum's own site, which currently shows only the unrelated consumer product's Pro packages starting at $30/month.",
         shortValue: '~$500/mo reported by a third party, unconfirmed by Vellum',
         confidence: 'unknown',
         sources: [
           {
             url: 'https://www.zenml.io/blog/vellum-ai-pricing',
             label: 'Vellum AI Pricing: ZenML Blog',
-            asOf: '2026-07-04',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -739,22 +759,27 @@ export const vellumProfile: CompetitorProfile = {
           {
             url: 'https://www.zenml.io/blog/vellum-ai-pricing',
             label: 'Vellum AI Pricing: ZenML Blog',
-            asOf: '2026-07-04',
+            asOf: '2026-10-15',
           },
         ],
       },
       byok: {
         value:
-          "Unconfirmed for the enterprise platform: Vellum's pricing page has been replaced by an unrelated consumer 'Personal Intelligence' product page, so BYOK availability can no longer be verified from vellum.ai/pricing.",
+          "Yes, per Vellum's platform docs: most provider models are enabled in a workspace by adding your own API key from that provider, and private models (OpenAI on Azure, OpenAI fine-tunes, Fireworks-hosted fine-tunes) can be connected. How this interacts with billing is not published",
         detail:
-          "The current pricing page describes Vellum-provided credits for the consumer product, not the enterprise platform's LLM-cost pass-through model; no bring-your-own-API-key policy is described for either product on this page.",
-        shortValue: 'Unverifiable after the pricing page pivoted to the consumer product',
-        confidence: 'unknown',
+          "The marketing pricing page now describes only the consumer 'Personal Intelligence' product, so this rests on the platform documentation, which carries no publication date.",
+        shortValue: 'Own provider keys per platform docs; billing effect unpublished',
+        confidence: 'estimated',
         sources: [
+          {
+            url: 'https://docs.vellum.ai/product/prompts/custom-models',
+            label: 'Vellum Docs: Custom Models',
+            asOf: '2026-10-15',
+          },
           {
             url: 'https://www.vellum.ai/pricing',
             label: 'Vellum Pricing (now shows the consumer product)',
-            asOf: '2026-07-08',
+            asOf: '2026-10-15',
           },
         ],
       },
diff --git a/apps/sim/lib/compare/data/sim.ts b/apps/sim/lib/compare/data/sim.ts
index e4fe00624d6..13d5835a40d 100644
--- a/apps/sim/lib/compare/data/sim.ts
+++ b/apps/sim/lib/compare/data/sim.ts
@@ -33,17 +33,17 @@ export const simProfile: CompetitorProfile = {
       shortDescription:
         'Chat builds and manages work across the workspace; in-editor Copilot edits a single workflow.',
       source: {
-        url: 'https://docs.sim.ai/copilot',
-        label: 'Sim Docs: Copilot',
+        url: 'https://docs.sim.ai/chat/workflows',
+        label: 'Sim Docs: Chat (build and edit workflows)',
         asOf: '2026-07-08',
       },
     },
     {
       title: 'Hybrid semantic + keyword knowledge base',
       description:
-        'Built-in RAG with pgvector embeddings and a generated tsvector column for combined vector + full-text search, plus a token-based chunker with configurable chunk size/overlap and 11 supported file formats (csv, doc, docx, html, json, md, pdf, pptx, txt, xlsx, yaml).',
+        'Built-in RAG with pgvector embeddings and a generated tsvector column for combined vector + full-text search, plus a token-based chunker with configurable chunk size/overlap and 12 supported document formats (csv, doc, docx, html, json, jsonl, md, pdf, pptx, txt, xlsx, yaml).',
       shortDescription:
-        'Combines vector and full-text search with configurable chunking across 11 file formats.',
+        'Combines vector and full-text search with configurable chunking across 12 document formats.',
       source: {
         url: 'https://github.com/simstudioai/sim/blob/main/packages/db/schema.ts',
         label: 'Sim codebase: KB schema + file-parsers',
@@ -80,7 +80,7 @@ export const simProfile: CompetitorProfile = {
       shortDescription:
         'Pause a run for human approval and resume later via a durable snapshot link.',
       source: {
-        url: 'https://docs.sim.ai/blocks/human-in-the-loop',
+        url: 'https://docs.sim.ai/workflows/blocks/human-in-the-loop',
         label: 'Sim Docs: Human in the Loop Block',
         asOf: '2026-07-02',
       },
@@ -88,8 +88,8 @@ export const simProfile: CompetitorProfile = {
     {
       title: 'Self-hostable under Apache 2.0',
       description:
-        'Fully open source (Apache 2.0), with Docker Compose files and a Helm chart for Kubernetes deployment, alongside a managed cloud-hosted option.',
-      shortDescription: 'Fully open source with Docker Compose and Helm deployment options.',
+        'Open-source core under Apache 2.0, with Docker Compose files and a Helm chart for Kubernetes deployment, alongside a managed cloud-hosted option. Enterprise features (SSO, SCIM, audit logs, access control, workspace forks) are separately licensed and require an Enterprise subscription for production use.',
+      shortDescription: 'Apache 2.0 core with Docker Compose and Helm deployment options.',
       source: {
         url: 'https://docs.sim.ai/introduction',
         label: 'Sim Docs: Introduction (FAQ - Open Source License)',
@@ -166,12 +166,12 @@ export const simProfile: CompetitorProfile = {
         confidence: 'verified',
         sources: [
           {
-            url: 'https://docs.sim.ai/self-hosting/docker',
+            url: 'https://docs.sim.ai/platform/self-hosting/docker',
             label: 'Sim Docs: Self-Hosting with Docker',
             asOf: '2026-07-02',
           },
           {
-            url: 'https://docs.sim.ai/self-hosting/kubernetes',
+            url: 'https://docs.sim.ai/platform/self-hosting/kubernetes',
             label: 'Sim Docs: Kubernetes (Helm) self-hosting',
             asOf: '2026-07-02',
           },
@@ -211,8 +211,9 @@ export const simProfile: CompetitorProfile = {
         ],
       },
       license: {
-        value: 'Apache License 2.0',
-        shortValue: 'Apache 2.0',
+        value:
+          'Apache License 2.0 for the core; enterprise features are under the separate Sim Enterprise License, which requires an Enterprise subscription for production use',
+        shortValue: 'Apache 2.0 core; enterprise features separately licensed',
         confidence: 'verified',
         sources: [
           {
@@ -366,9 +367,9 @@ export const simProfile: CompetitorProfile = {
     aiCapabilities: {
       multiLlmSupport: {
         value:
-          '21 provider integrations (OpenAI, Anthropic, Google/Gemini, Azure OpenAI, Azure Anthropic, Groq, Cerebras, Mistral, xAI, Bedrock, Vertex, Ollama, OpenRouter, and more), with OpenRouter, LiteLLM, vLLM, and Ollama resolving models dynamically at runtime rather than from a fixed list, so effective model reach extends well beyond the 21 named providers',
-        detail: 'apps/sim/providers/models.ts defines 21 provider entries.',
-        shortValue: '21 providers plus dynamic-resolution aggregators (OpenRouter, LiteLLM, etc.)',
+          '28 provider integrations (OpenAI, Anthropic, Google/Gemini, Azure OpenAI, Azure Anthropic, Vertex, Bedrock, xAI, Mistral, DeepSeek, Groq, Cerebras, Fireworks, Together, Ollama, OpenRouter, and more), with OpenRouter, LiteLLM, vLLM, and Ollama resolving models dynamically at runtime rather than from a fixed list, so effective model reach extends well beyond the 28 named providers',
+        detail: 'apps/sim/providers/models.ts defines 28 provider entries.',
+        shortValue: '28 providers plus dynamic-resolution aggregators (OpenRouter, LiteLLM, etc.)',
         confidence: 'verified',
         sources: [
           {
@@ -398,15 +399,15 @@ export const simProfile: CompetitorProfile = {
         confidence: 'verified',
         sources: [
           {
-            url: 'https://docs.sim.ai/copilot',
-            label: 'Sim Docs: Copilot',
+            url: 'https://docs.sim.ai/chat/workflows',
+            label: 'Sim Docs: Chat (build and edit workflows)',
             asOf: '2026-07-02',
           },
         ],
       },
       knowledgeBaseRag: {
-        value: `Yes: hybrid vector (pgvector) plus full-text (tsvector) search knowledge base, 11 supported file formats (csv, doc, docx, html, json, md, pdf, pptx, txt, xlsx, yaml), configurable chunking, plus ${CONNECTOR_COUNT_LABEL} connectors that continuously sync external sources (Google Drive, Confluence, Slack, Gmail, GitHub, HubSpot, Linear, Jira, and more) into the knowledge base rather than a one-shot upload`,
-        shortValue: `Hybrid vector + full-text search, 11 file formats, ${CONNECTOR_COUNT_LABEL} connectors`,
+        value: `Yes: hybrid vector (pgvector) plus full-text (tsvector) search knowledge base, 12 supported document formats (csv, doc, docx, html, json, jsonl, md, pdf, pptx, txt, xlsx, yaml), configurable chunking, plus ${CONNECTOR_COUNT_LABEL} connectors that continuously sync external sources (Google Drive, Confluence, Slack, Gmail, GitHub, HubSpot, Linear, Jira, and more) into the knowledge base rather than a one-shot upload`,
+        shortValue: `Hybrid vector + full-text search, 12 document formats, ${CONNECTOR_COUNT_LABEL} connectors`,
         confidence: 'verified',
         sources: [
           {
@@ -433,7 +434,7 @@ export const simProfile: CompetitorProfile = {
         confidence: 'verified',
         sources: [
           {
-            url: 'https://docs.sim.ai/mcp',
+            url: 'https://docs.sim.ai/agents/mcp',
             label: 'Sim Docs: Using MCP Tools',
             asOf: '2026-07-02',
           },
@@ -453,12 +454,12 @@ export const simProfile: CompetitorProfile = {
         confidence: 'verified',
         sources: [
           {
-            url: 'https://docs.sim.ai/blocks/evaluator',
+            url: 'https://docs.sim.ai/workflows/blocks/evaluator',
             label: 'Sim Docs: Evaluator Block',
             asOf: '2026-07-02',
           },
           {
-            url: 'https://docs.sim.ai/blocks/guardrails',
+            url: 'https://docs.sim.ai/workflows/blocks/guardrails',
             label: 'Sim Docs: Guardrails Block',
             asOf: '2026-07-02',
           },
@@ -471,7 +472,7 @@ export const simProfile: CompetitorProfile = {
         confidence: 'verified',
         sources: [
           {
-            url: 'https://docs.sim.ai/blocks/human-in-the-loop',
+            url: 'https://docs.sim.ai/workflows/blocks/human-in-the-loop',
             label: 'Sim Docs: Human in the Loop Block',
             asOf: '2026-07-02',
           },
@@ -549,7 +550,7 @@ export const simProfile: CompetitorProfile = {
         confidence: 'verified',
         sources: [
           {
-            url: 'https://docs.sim.ai/skills',
+            url: 'https://docs.sim.ai/agents/skills',
             label: 'Sim Docs: Agent skills',
             asOf: '2026-07-02',
           },
@@ -642,7 +643,7 @@ export const simProfile: CompetitorProfile = {
             asOf: '2026-10-13',
           },
           {
-            url: 'https://docs.sim.ai/tools',
+            url: 'https://docs.sim.ai/integrations',
             label: 'Sim Docs: Integrations / Tools Overview',
             asOf: '2026-07-02',
           },
@@ -659,7 +660,7 @@ export const simProfile: CompetitorProfile = {
         confidence: 'verified',
         sources: [
           {
-            url: 'https://docs.sim.ai/triggers',
+            url: 'https://docs.sim.ai/workflows#triggers',
             label: 'Sim Docs: Triggers overview',
             asOf: '2026-07-02',
           },
@@ -721,7 +722,7 @@ export const simProfile: CompetitorProfile = {
             asOf: '2026-07-08',
           },
           {
-            url: 'https://docs.sim.ai/execution/api',
+            url: 'https://docs.sim.ai/api-reference/getting-started',
             label: 'Sim Docs: External API',
             asOf: '2026-07-08',
           },
@@ -744,7 +745,7 @@ export const simProfile: CompetitorProfile = {
             asOf: '2026-07-04',
           },
           {
-            url: 'https://docs.sim.ai/mcp',
+            url: 'https://docs.sim.ai/agents/mcp',
             label: 'Sim Docs: Using MCP Tools',
             asOf: '2026-07-02',
           },
@@ -772,14 +773,14 @@ export const simProfile: CompetitorProfile = {
     pricing: {
       pricingModel: {
         value:
-          'Credit-based usage billing (Stripe), with bring-your-own-key exemption from metered caps',
-        shortValue: 'Credit-based billing, BYOK exempt from caps',
+          "Credit-based usage billing (Stripe); bring-your-own-key calls skip Sim's model and tool usage charge, while the base per-run charge still applies",
+        shortValue: 'Credit-based billing; BYOK skips model usage charges',
         confidence: 'verified',
         sources: [
           {
             url: `${SITE_URL}/pricing`,
             label: 'Sim Pricing',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -791,7 +792,7 @@ export const simProfile: CompetitorProfile = {
           {
             url: `${SITE_URL}/pricing`,
             label: 'Sim Pricing',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -804,35 +805,35 @@ export const simProfile: CompetitorProfile = {
           {
             url: `${SITE_URL}/pricing`,
             label: 'Sim Pricing',
-            asOf: '2026-08-26',
+            asOf: '2026-10-15',
           },
           {
             url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/lib/billing/constants.ts',
             label: 'Sim codebase: DEFAULT_FREE_CREDITS',
-            asOf: '2026-08-26',
+            asOf: '2026-10-15',
           },
         ],
       },
       byok: {
         value:
-          'Yes: bring-your-own-key support exempts usage from metered credit caps, and multiple keys stored for the same provider are automatically round-robin rotated, with automatic fallback past any key that fails to decrypt',
-        shortValue: 'BYOK exempts credit caps; multi-key round-robin rotation',
+          "Yes: bring-your-own-key provider calls skip Sim's model and tool usage charge (the base per-run charge still applies); workspace keys work on any plan, organization keys need a team or Enterprise plan, and multiple keys stored for the same provider are round-robin rotated, skipping any key that fails to decrypt",
+        shortValue: 'BYOK skips model usage charges; multi-key round-robin rotation',
         confidence: 'verified',
         sources: [
           {
             url: 'https://docs.sim.ai/platform/costs#bring-your-own-key-byok',
             label: 'Sim Docs: Bring Your Own Key (BYOK)',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
           {
             url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/lib/billing/calculations/usage-monitor.ts',
             label: 'Sim codebase: BYOK usage-monitor logic',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
           {
             url: 'https://github.com/simstudioai/sim/blob/main/apps/sim/lib/api-key/byok.ts',
             label: 'Sim codebase: BYOK key rotation',
-            asOf: '2026-07-02',
+            asOf: '2026-10-15',
           },
         ],
       },
@@ -863,7 +864,7 @@ export const simProfile: CompetitorProfile = {
         confidence: 'verified',
         sources: [
           {
-            url: 'https://docs.sim.ai/self-hosting/docker',
+            url: 'https://docs.sim.ai/platform/self-hosting/docker',
             label: 'Sim Docs: Self-Hosting with Docker',
             asOf: '2026-07-02',
           },
@@ -946,7 +947,7 @@ export const simProfile: CompetitorProfile = {
             asOf: '2026-07-02',
           },
           {
-            url: 'https://docs.sim.ai/permissions/roles-and-permissions',
+            url: 'https://docs.sim.ai/platform/permissions',
             label: 'Sim Docs: Roles and Permissions',
             asOf: '2026-07-02',
           },
@@ -961,7 +962,7 @@ export const simProfile: CompetitorProfile = {
         confidence: 'verified',
         sources: [
           {
-            url: 'https://docs.sim.ai/permissions/roles-and-permissions',
+            url: 'https://docs.sim.ai/platform/permissions',
             label: 'Sim Docs: Roles and Permissions',
             asOf: '2026-07-02',
           },
@@ -1005,7 +1006,7 @@ export const simProfile: CompetitorProfile = {
         confidence: 'verified',
         sources: [
           {
-            url: 'https://docs.sim.ai/blocks/guardrails',
+            url: 'https://docs.sim.ai/workflows/blocks/guardrails',
             label: 'Sim Docs: Guardrails Block',
             asOf: '2026-07-02',
           },
@@ -1075,7 +1076,7 @@ export const simProfile: CompetitorProfile = {
             asOf: '2026-07-02',
           },
           {
-            url: 'https://docs.sim.ai/execution/logging',
+            url: 'https://docs.sim.ai/logs-debugging/logging',
             label: 'Sim Docs: Logging',
             asOf: '2026-07-02',
           },
@@ -1201,7 +1202,7 @@ export const simProfile: CompetitorProfile = {
             asOf: '2026-07-02',
           },
           {
-            url: 'https://docs.sim.ai/triggers',
+            url: 'https://docs.sim.ai/workflows#triggers',
             label: 'Sim Docs: Triggers',
             asOf: '2026-07-02',
           },
diff --git a/apps/sim/lib/compare/data/types.ts b/apps/sim/lib/compare/data/types.ts
index 88f9db4d59a..57827d88881 100644
--- a/apps/sim/lib/compare/data/types.ts
+++ b/apps/sim/lib/compare/data/types.ts
@@ -232,6 +232,12 @@ export interface CompetitorProfile {
    * decides it. 3-5 sentences.
    */
   betterThanAnswer?: Prose
+  /**
+   * Hand-written FAQs answering this competitor's tracked buyer prompts, shown
+   * ahead of the generated FAQ set. Answer-first, and every answer names both
+   * products so it can be quoted on its own.
+   */
+  faqs?: Array<{ question: string; answer: string }>
   /**
    * One-sentence lead-in per comparison-table section, stating what that
    * section covers so the section is quotable without the rest of the page.
diff --git a/apps/sim/scripts/test-landing-seo-e2e.ts b/apps/sim/scripts/test-landing-seo-e2e.ts
index 2ea7dc57baa..bfd0f54b681 100644
--- a/apps/sim/scripts/test-landing-seo-e2e.ts
+++ b/apps/sim/scripts/test-landing-seo-e2e.ts
@@ -8,6 +8,16 @@ import {
 import integrationsJson from '@sim/deployment-config/integrations.json'
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
+import {
+  dustProfile,
+  gumloopProfile,
+  langflowProfile,
+  n8nProfile,
+  openClawProfile,
+  pipedreamProfile,
+  vellumProfile,
+} from '@/lib/compare/data'
+import { INTEGRATION_SEO } from '@/app/(landing)/integrations/data/seo-content'
 
 /**
  * Crawls a running landing site the way a search or AI crawler does: plain GETs, no JavaScript,
@@ -94,6 +104,23 @@ function jsonLdNodes(html: string): Record<string, unknown>[] {
   return nodes
 }
 
+/** Undoes the entity escaping React applies to text, so rendered copy compares to its source. */
+function decodeHtml(html: string): string {
+  return html
+    .replace(/&#x27;|&#39;/g, "'")
+    .replace(/&quot;/g, '"')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&')
+}
+
+/** Question text of every FAQPage entry on the page, in order. */
+function faqQuestions(html: string): string[] {
+  const faqPage = jsonLdNodes(html).find((node) => node['@type'] === 'FAQPage')
+  const entries = (faqPage?.mainEntity ?? []) as { name?: string }[]
+  return entries.map((entry) => entry.name ?? '')
+}
+
 /** Paths and lastmod values from the sitemap, keyed by path. */
 async function readSitemap(): Promise<Map<string, string | undefined>> {
   const { status, body } = await get('/sitemap.xml')
@@ -240,6 +267,59 @@ async function run() {
     assert(String(product['@id']).endsWith('#software'), `Offers sit on ${product['@id']}`)
   })
 
+  await check('comparison pages lead with their answer and their tracked-prompt FAQs', async () => {
+    const failures: string[] = []
+    for (const profile of [
+      n8nProfile,
+      dustProfile,
+      gumloopProfile,
+      vellumProfile,
+      langflowProfile,
+      pipedreamProfile,
+      openClawProfile,
+    ]) {
+      const { status, body } = await get(`/comparisons/${profile.id}`)
+      if (status !== 200) {
+        failures.push(`${profile.id}: status ${status}`)
+        continue
+      }
+      const text = decodeHtml(body)
+      const lead = profile.leadAnswer?.map((part) => (typeof part === 'string' ? part : part.text))
+      const firstSection = text.indexOf('<h2')
+      const leadAt = lead ? text.indexOf(lead.join('')) : -1
+      if (leadAt < 0 || leadAt > firstSection) {
+        failures.push(`${profile.id}: lead answer missing or below the first section`)
+      }
+      const expected = (profile.faqs ?? []).map((faq) => faq.question)
+      const questions = faqQuestions(body).slice(0, expected.length)
+      if (expected.length === 0 || questions.join('|') !== expected.join('|')) {
+        failures.push(`${profile.id}: FAQPage does not open with the profile FAQs`)
+      }
+    }
+    assert.deepEqual(failures, [])
+  })
+
+  await check('rebuilt integration pages render their comparison and FAQs', async () => {
+    const failures: string[] = []
+    for (const slug of ['github', 'shopify', 'snowflake']) {
+      const seo = INTEGRATION_SEO[slug]
+      const { status, body } = await get(`/integrations/${slug}`)
+      if (status !== 200) {
+        failures.push(`${slug}: status ${status}`)
+        continue
+      }
+      const text = decodeHtml(body)
+      if (!seo?.comparison || !text.includes(seo.comparison.heading)) {
+        failures.push(`${slug}: comparison section missing`)
+      }
+      const expected = (seo?.faqs ?? []).map((faq) => faq.question)
+      if (expected.length === 0 || faqQuestions(body).join('|') !== expected.join('|')) {
+        failures.push(`${slug}: FAQPage does not match the hand-written FAQs`)
+      }
+    }
+    assert.deepEqual(failures, [])
+  })
+
   await check('blog, library, and changelog advertise their RSS feeds', async () => {
     const missing: string[] = []
     for (const [path, feed] of [