Sim vs Make
Sim is the open-source AI workspace where teams build, deploy, and manage AI agents visually, conversationally, or with code. Here is how Sim compares to Make on platform architecture, AI capabilities, integrations, pricing, security, and support. Every fact below is sourced and dated.
Sim is an open-source AI workspace for building, deploying, and managing AI agents. This page compares Sim to Make across platform architecture, AI capabilities, integrations, pricing, security and compliance, observability, and support, using sourced, dated facts for buyers evaluating both platforms.
What is Sim?
Sim is the open-source AI workspace where teams build, deploy, and manage AI agents, connecting 1,000+ integrations and every major LLM to automate real work visually, conversationally, or with code.
What is Make?
Make (make.com) is a closed-source, cloud-only visual workflow-automation platform where users connect app "modules" on a canvas into scenarios. It now also offers AI Agent blocks, an MCP server, and a JS/Python code step, billed on a per-module-execution credit model.
Sim vs Make: feature-by-feature comparison
CompareSim vs Make
Sim
Make
Platform
Builder type
Sim
Visual canvas, chat, or codeVisual drag-and-drop canvas, natural-language (Chat), or code (API/SDK)
Make
Visual drag-and-drop canvas with optional code stepVisual, node/module-based drag-and-drop scenario builder. Make's core paradigm is a visual canvas where users connect 'modules' (app actions/triggers) with routers, filters, iterators, and aggregators into a 'scenario'. AI Agents (2026) are built as blocks inside the same visual canvas, not a separate code environment. A 'Make Code' module (JS/Python) can be dropped in for pro-code logic, making it primarily visual with an optional code escape hatch (hybrid).
Learning curve
Sim
Low, plus natural-language Chat for non-technical usersLow for visual building; natural-language Chat surface (with a workflow-scoped Copilot) for non-technical builders. Chat lets users describe a workflow in plain language and have Sim scaffold or edit it; the visual canvas requires no code to connect blocks.
Make
Easy for basics, steep for advanced logicLow for simple linear automations; moderate-to-steep for complex branching/error-handling logic. Third-party reviews consistently describe Make as having a steeper learning curve than simpler tools like Zapier: new users need time to understand field mapping and branching, while routers, filters, iterators/aggregators, and error handlers give more control for complex, multi-step workflows once learned.
Self-hosting
Make
No general self-hosting; cloud SaaS only, with a limited 'on-premise agent' for connecting internal networks. Make is a fully managed SaaS platform. Scenarios, credentials, and execution run on Make's own AWS infrastructure (US or EU data centers). There is no option to run the full Make engine on customer infrastructure. Make does offer an installable 'on-premise agent' (Java-based) that lets scenarios reach systems inside a private network, but this is a connectivity bridge, not a self-hosted deployment of Make itself.
Deployment options
Sim
Cloud-hosted or self-hosted, no mid-tier VPC optionCloud-hosted (managed, multi-tenant SaaS) or self-hosted (Docker/Kubernetes). No documented managed single-tenant/VPC hosting tier in between. The Enterprise plan's only hosting-related row in the pricing comparison table is a boolean "Self Hosting" flag; there is no dedicated-instance/VPC offering.
Make
Multi-tenant AWS cloud; isolated tier for EnterpriseCloud only (multi-tenant SaaS), with a separately isolated AWS environment for Enterprise. Runs on Amazon AWS EC2 within Amazon VPC, multi-zone for availability. Enterprise plan customers get a 'separately managed AWS environment, isolated from the self-service cloud customers.' No Docker/Kubernetes/on-prem deployment of the platform itself is offered.
Templates
Sim
License
Sim
Apache 2.0Apache License 2.0
Make
Closed-source, owned by CelonisProprietary. Make (owned by Celonis) is closed-source commercial software; the Master Services Agreement states Celonis remains the exclusive owner of all right, title, and interest in the Services, and bars customers from copying, modifying, or reverse-engineering the platform, so there is no open-source license or public source repository.
Environment promotion
Sim
Yes: fork a whole workspace into a dev/qa/prod-style child, diff it, and promote or roll back changes in either direction. Credential and env-var remapping is required before every promote, so secrets are never silently copied across environments. Gated to Enterprise plan on hosted Sim, or a FORKING_ENABLED flag on self-hosted deployments.
Make
No formal dev/qa/prod environment-promotion pipeline; only manual clone/export-import of whole scenarios between teams or organizations. Make's organizational hierarchy is Organization > Teams, where teams scope access to templates, connections, webhooks, keys, data stores, and more. There is no dedicated 'environment' concept (e.g. dev/staging/prod) with a push/pull promotion workflow. The closest capability is manually cloning a scenario (Options > Clone) within the same organization, or exporting/importing a scenario's blueprint (JSON) between organizations, a process that loses existing connections and webhooks, which must be reconfigured afterward.
Version control
Sim
Deployment rollback plus Copilot edit diff/revertDeployed-version history with rollback for every workflow; server-persisted checkpoint/revert and visual diff (accept/reject) specifically for Copilot AI edits. Manual drag-and-drop undo/redo is client-side/localStorage only (capped at 100 ops, 5 stacks), not server-synced across devices. Deployment history does not include an arbitrary version-to-version diff tool, and knowledge base documents have no version history.
Make
Linear version history and restore, no branchingVersion history with restore (up to plan-dependent retention, commonly cited as up to 60 days), plus a Cancel-to-revert unsaved-change safety net; no true undo/redo, no confirmed diff/compare view, no branching. Make lets users access and restore previously saved scenario versions (retention depends on pricing plan, commonly up to 60 days) to revert unwanted changes. There is no traditional undo/redo, but hitting 'Cancel' while editing discards unsaved changes and reverts to the last saved version. Execution/change history (separate from version history) logs run results and user edits (scheduling changes, edits, activation) and can be exported as CSV. Make's Help Center does not document a visual diff/compare view between two saved versions, and there is no branching model, only linear version history per scenario.
Realtime collaboration
Sim
Make
No: Make does not support live, concurrent multi-user editing of the same scenario with synced cursors or selections. If two people edit the same scenario at the same time, the last person to save overwrites the other's changes; there is no real-time co-editing.. Make supports async scenario sharing (share a link/copy) and team-based access, but not simultaneous live editing with visible collaborators.
Native file storage
Sim
Yes: a native Files area with folder hierarchy, link-based sharing (public, password, email OTP, or SSO auth), and a workspace-level Recently Deleted view covering workflows, tables, knowledge bases, files, and folders. Admins can restrict which share-auth modes (public/password/email/SSO) a permission group is allowed to use.
Make
No: Make has no native file-storage system with folder hierarchy, link-based sharing (password/SSO options), and deleted-item recovery. Make's file handling is per-module/per-scenario (download, upload, transform, move files between apps and connected storage services like Google Drive, Box, Files.com), not a dedicated in-platform file store.. No dedicated Make file-storage/folder/trash feature is documented; only third-party storage app integrations and generic file-mapping help pages exist.
Native data tables
Sim
Yes: a native spreadsheet-like Tables feature (typed columns, not an external DB connector) with full keyboard support (arrow keys, Tab, copy-paste bulk load, Cmd/Ctrl+Z undo) and atomic per-row writes from multiple workflows at once. No public fixed row-limit figure is documented (guidance says paginate reads past ~100k rows); a workflow can also be wired to run per row via a "workflow column."
Make
Yes: Make has a native Data Stores feature for storing structured records (fields/columns and items/rows), with a browsable table view in the UI for adding, viewing, updating, and deleting records. It behaves more like a key-value record store than a full spreadsheet: limits are size-based (1MB per store on Core, 10MB on Pro/Teams, custom on Enterprise, with per-record caps reported at 512KB-15MB depending on the source) rather than fixed row/column counts, and it lacks spreadsheet-style keyboard navigation (arrow-key cell movement, multi-cell copy-paste).. UI supports a table/grid browse view and manual record add/edit, but bulk spreadsheet-like editing (arrow-key navigation, drag-fill, multi-cell paste) is not documented.
Rich-text document editor
Sim
Make
No: Make does not have a native inline rich-text/WYSIWYG editor for documents stored in the platform. Document creation happens through integrations such as Google Docs, where the 'Create a Document' module accepts plain text or HTML strings as input rather than offering an in-app editing surface. Make also ships a plain Markdown-related app/module for text conversion, not an editor.. Google Docs module supports HTML-formatted content field, and a separate Markdown app exists for parsing/conversion, but neither is an in-platform rich text editor UI.
Sub-workflows (composition)
Sim
Make
Yes: Make's 'Call a Scenario' subscenario module lets a parent scenario invoke a saved sub-scenario as a step, passing structured inputs and, in synchronous mode, pausing until the sub-scenario finishes and returns outputs via a 'Return outputs' module.. Make's Subscenarios feature supports two modes: synchronous, where the parent calls the sub-scenario and pauses execution until it completes and returns output; and asynchronous, where the parent continues immediately without waiting. Each call creates its own separately logged run, and an error in the sub-scenario propagates back to the parent's error handling. This is a dedicated composition feature, distinct from triggering an unrelated scenario via a plain webhook.
Custom blocks (org-wide reuse)
Sim
Yes: a user with admin access on a workflow's workspace can publish its deployed version as a named, iconed custom block that appears in the block toolbar for the whole organization. Inputs are read live from the source workflow's Start block; the publisher picks which outputs to expose. The block always runs the source workflow's latest deployed version, and its internal steps and intermediate values are never exposed to consumers. Enterprise-gated on Sim Cloud; self-hosted deployments can opt in via a feature flag. Distinct from the Workflow (sub-workflow) block, which composes a workflow the same author controls, and from custom code/tool blocks, which run inline code rather than a full deployed workflow.
Make
No: Make has no feature to publish an existing scenario as an encapsulated, named block that appears in a shared module toolbar for other users across the organization to drop into their own separate scenarios. The closest capabilities are each narrower: 'Call a Scenario' (Subscenarios) can only invoke a scenario already created within the same team, is not exposed as a general block in a module picker, and Make's own docs don't describe it as hiding internal steps or always tracking a source's latest published version. 'Scenarios as AI Agent tools' lets a scenario's defined inputs/outputs be used as a callable tool, but only inside that specific AI Agent's own tool configuration, not as a general-purpose block any builder can add to any regular scenario. The Custom Apps SDK builds brand-new integration connectors that wrap third-party REST APIs; it has no mechanism to package an existing scenario itself as a block.. Per Make's Subscenarios help doc, you can 'only call a scenario created in your team,' scoping reuse to team boundaries rather than an org-wide block toolbar, with no documented internals-hiding or auto-latest-version guarantee. Per the Scenarios-for-AI-agents help doc, scenario-as-tool configuration happens inside AI Agents' own tab/module, not as a block available to all scenario builders. Per the Custom Apps Developer Hub, Custom Apps exist to integrate a third-party application that has no existing Make app, mapping REST endpoints and auth, not to publish an existing scenario as a reusable block.
Pricing
Pricing model
Sim
Credit-based billing, BYOK exempt from capsCredit-based usage billing (Stripe), with bring-your-own-key exemption from metered caps
Make
Credits consumed per module executionCredit-based subscription (monthly credit allotment; each module action/execution consumes 1 credit). Make's pricing page states: 'each module action in your scenario, like adding a Google Sheet row or fetching Gmail account data, counts as one credit.' Plans are sold in credit tiers (starting at 10,000 credits/month for the cheapest listed prices), with annual billing discounted 15%+.
Entry paid plan
Sim
Pro plan at $25/user/monthPro: $25 per user/month
Make
Core plan, $12/mo for 10,000 creditsCore plan. $12/month for 10,000 credits/month (lowest listed price point). Core adds over Free: unlimited active scenarios, scheduled scenarios down to 1-minute intervals, increased data transfer/file-size limits (5GB/100MB), and access to the Make API.
Free tier
Sim
Bring your own key
Sim
Make
Yes: Make supports bringing your own LLM key for AI Agents, as an alternative to Make's own AI Provider, available on all plans. Make's pricing page states organizations can build and manage AI Agents using Make's own AI Provider (all plans) or their own LLM key, confirming BYOK for LLM API keys is directly supported and available on every plan, not just higher tiers.
Security & compliance
SOC 2
Data residency
Sim
Full control via self-hosting; Cloud region toggle is global, not per-customerFull data control via self-hosting (Docker/Kubernetes); data never leaves customer infrastructure when self-hosted. On Sim Cloud, async job execution has an internal US/EU region toggle, but it is deployment-wide, not a customer-selectable per-workspace residency option
Make
Yes: choice of US or EU data center at organization creation; Enterprise gets an isolated AWS environment. Each Make organization selects a data-center region (US or EU, e.g. eu1.make.com) at creation time; this cannot be changed afterward. Enterprise customers additionally run in a 'separately managed AWS environment, isolated from self-service cloud customers.'
Role-based access control
Sim
Yes: admin/write/read workspace permissions, org-level admin/member roles, plus Enterprise-tier permission groups that allow/deny-list specific models, tools, and integrations per group on top of those base roles. See modelAndToolGovernance and credentialGovernance for the finer-grained permission-groups layer.
Make
Yes: 'Teams and team roles' with unlimited team permissions, on Teams and Enterprise plans. Make's pricing page describes 'Teams and team roles' enabling 'unlimited team permissions for scenario apps, templates, and connections' on the Teams and Enterprise tiers; lower tiers get unlimited users but not the granular role/team management.
Audit logging
Sim
Make
Yes: Audit logs available on Teams and Enterprise plans; retained 30 days by default. Make's pricing page lists 'Audit logs' as a Teams/Enterprise feature documenting user actions. The Security page states log data is stored 30 days by default on general plans, with an extended (unspecified) retention period available on Enterprise.
Additional compliance
Sim
SOC2SOC2. Self-hosting is the primary lever Sim offers for data-residency-sensitive compliance needs beyond SOC2, rather than additional certifications.
Make
No HIPAA, PCI, or FedRAMPSOC 2 Type II, SOC 3, and ISO 27001 certified, plus GDPR adherence; no HIPAA, PCI, or FedRAMP mentioned. Make's Security page states the company operates an ISO 27001-certified information security program and runs infrastructure compliant with SOC 3 and SOC 2 Type II audits, alongside GDPR adherence (Make also has a dedicated GDPR page). HIPAA compliance is not mentioned or offered.
Model & tool governance
Sim
Yes: enterprise "permission groups" let an admin allow-list/deny-list specific LLM providers and models, and separately deny specific tools/integrations (or disable all MCP or custom tools) per group, layered on top of workspace admin/write/read roles. This does not control whether an LLM provider retains prompts. Sim offers no "zero data retention" mode or governed AI gateway. A separate, Enterprise-gated feature lets orgs set a log-retention window and redact PII, but that only controls how long Sim itself keeps execution logs.
Make
Not publicly documentedNot publicly documented. Make has not published documentation describing model- or tool-level governance controls for AI Agents.
Credential governance
Sim
Yes: shared credentials (connected accounts, service accounts, workspace secrets) are their own nested permission level (Member/Admin) below organization and workspace roles, and enterprise permission groups can further allow-list specific integrations and restrict which file-share auth modes (public/password/email/SSO) a group may use. A user's personal environment variables/secrets are never shared or inherited by anyone, including org owners/admins.
Make
No: Make's connection access control is team-scoped, not credential-specific. Connections created within a team are visible and usable by all members with at least the Restricted Team Member role. Instance/organization user roles can be customized, but there is no documented way to restrict a role or permission group to specific individual stored credentials beyond team membership.. White Label docs describe customizable instance-level user roles and team permissions (add/edit/delete connections), but no per-credential allowlisting within a role was found.
Single sign-on (SSO)
Sim
Make
Yes: Make offers enterprise single sign-on supporting both SAML 2.0 and OpenID Connect (OAuth 2.0-based), configurable per organization, with documented identity provider support for Okta (SAML) and Microsoft Azure AD (SAML and OIDC), plus domain claiming to prevent self-service account creation outside SSO.. SSO is configured per organization and is part of Make's enterprise/White Label offering; Google SAML is also referenced as supported.
Vetted first-party integrations
Sim
Yes: every one of Sim's 266 blocks is first-party authored and code-reviewed through the standard pull-request process in the main Sim repository; there is no public marketplace where an arbitrary third party can publish and have other users install executable tool code without going through Sim's own review. Custom code steps run inside Sim's own isolated-vm sandbox rather than as an installable third-party skill package, so the supply-chain trust boundary is Sim's codebase review, not an open registry.
Make
Partial: open custom apps, but QA-reviewed before public marketplace listingPartial: any developer can build a custom Make app, but publishing it to the public Apps Marketplace requires passing a Make QA code review before it becomes available to all users. Make's Developer Hub documents an open custom-app development model (any third-party developer can build and privately use a custom app), combined with a gated marketplace: to share an app with all Make users, the developer must request an app review, and Make's QA team examines the app's code against app standards and best practices (including sanitization of sensitive data such as API keys/tokens) before publishing it publicly. This is a lighter-touch, code-reviewed model rather than either a fully closed first-party catalog or a fully open, unreviewed community marketplace. No security incident involving malicious or credential-leaking third-party Make apps has been publicly documented.
PII redaction
Sim
Make
Unknown: no documented PII redaction featureUnknown: No public Make documentation was found describing a built-in feature to detect and redact/block PII (emails, SSNs, etc.) in workflow content or retained execution logs. This is distinct from generic output-validation guardrails, which also were not documented for Make.. Searches returned only generic third-party PII/data-masking explainer content, nothing Make-specific.
Custom data retention
Sim
Make
Yes (partially): Execution/run history retention in Make is plan-dependent, with longer retention on higher-tier plans, rather than freely configurable by default. White Label instance admins can set organization log retention (default 60 days if unset), and audit logs can retain data for up to 365 days.. Standard Make plans get a fixed retention window tied to pricing tier; granular org-configurable retention (beyond plan tier) appears mainly in the White Label/OEM product, not confirmed for standard Team/Enterprise orgs.
White-labeling
Sim
Make
Yes: Make offers a White Label / OEM product that lets a customer rebrand a Make instance with their own product name (shown in browser tab and emails), custom login-page and UI colors, custom favicon, and custom logos for light and dark backgrounds.. This is a separate enterprise/OEM offering from standard Make plans, documented in the Make White Label Developer Hub.
AI capabilities
Multi-LLM support
Sim
21 providers plus dynamic-resolution aggregators (OpenRouter, LiteLLM, etc.)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. apps/sim/providers/models.ts defines 21 provider entries.
Make
Yes: OpenAI, Anthropic Claude, Google Vertex AI (Gemini), Azure OpenAI, Mistral AI, Perplexity AI, Hugging Face, plus OpenAI-compatible custom models. Make's AI Agents page lists these integrated providers; AI Agent configuration docs also mention support for 'various LLMs including OpenAI-compatible models.'
Agent reasoning blocks
Sim
Make
Yes: dedicated AI Agent blocks with a visible reasoning/decision panel, distinct from plain data-routing modules. Make AI Agents (rolled out to all paid plans as of Jan 19, 2026) provide adaptive decision-making inside scenarios, with a 'Reasoning panel' on the canvas showing step-by-step decisions, plus manual-approval/stop-point guardrails so agents work alongside deterministic logic rather than replacing it.
Natural-language building
Make
No native prompt-to-scenario copilotNot a native, officially-branded feature. Natural-language scenario creation is available only through third-party/unofficial MCP servers (e.g., community 'make-mcp-server') feeding prompts to external AI assistants like Claude or Cursor, plus Make's own MCP Server letting external agents call Make scenarios as tools. Make has no first-party 'type a prompt, Make builds the scenario' copilot feature.
Knowledge base / RAG
Sim
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 51 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
MCP support
Sim
Evaluation & guardrails
Sim
LLM-judge Evaluator plus Guardrails validation blockEvaluator block (LLM-judge scoring against user-defined named metrics) and Guardrails block (JSON validity, regex, RAG/hallucination scoring, PII detection/masking). These are per-call scoring/validation primitives, not a batch golden-dataset eval-suite runner or A/B prompt-testing harness.
Make
Manual approvals only, no automated eval suitePartial: manual approval steps and stop points for agents; no dedicated automated eval/testing suite. Make's AI Agents documentation describes user-configurable guardrails: 'set clear rules, add manual approvals, or stop the Agent at specific points,' with agents running alongside deterministic scenario logic. No dedicated automated evaluation/regression-testing framework (e.g., golden-dataset evals) is offered.
Human-in-the-loop
Sim
Make
Closed-beta review/approval app, Enterprise onlyDedicated Human in the Loop (Enterprise) app. Closed beta, invite-only, Enterprise plan. Make offers a distinct 'Human in the Loop (Enterprise)' app (separate from a plain Sleep/Wait module) that creates a review request, returns a review URL, and sends the reviewed data to a webhook the customer defines. Notification/approval routing (email, Slack, custom form) is configured by the customer via that webhook rather than a fixed built-in channel. The scenario pauses at the module; a companion trigger 'Watch completed reviews' fires when a review is approved, adjusted, or canceled, letting the scenario branch and resume based on the reviewer's decision. As of 2026-07-02 this app is in closed beta, available only to invited Enterprise customers.
Generative media
Sim
Make
No native built-in image/video/audio generation blocks; achieved only via third-party AI app integrations. Make does not ship its own first-party image, video, or TTS/STT generation modules. Generative-media workflows are built by wiring in separate apps/integrations for those providers (e.g. DALL·E for images, ElevenLabs for audio/TTS) as separate modules within a scenario rather than a native 'generate image/video/audio' block owned by Make.
Dynamic tool use
Sim
No: an Agent block calls tools the workflow author explicitly added to it at build time, rather than browsing and picking from a broader pool (e.g. an entire MCP server catalog) at inference time. Runtime MCP "discovery" exists to resolve/refresh the schema of an already-configured tool. The model does not browse or choose from the server's full tool list.
Make
Not publicly documentedNot publicly documented. Make has not published documentation describing dynamic tool-selection behavior for AI Agents.
Automatic model fallback
Sim
No: a failed or rate-limited LLM call is retried using Sim's own hosted API keys for the same model, rather than automatically switching to a different model or provider. A "fallback" comment in the provider layer refers to rotating among Sim's own hosted API keys for the same model, not switching models.
Make
Not publicly documentedNot publicly documented. Make has not published documentation describing automatic model-fallback behavior for AI Agents.
Agent skills
Sim
Yes: named, reusable "Agent Skills" (built on the open Agent Skills / SKILL.md format) that agents load on demand via progressive disclosure, editable in-app or imported from a SKILL.md file or GitHub URL. Only the skill name and description sit in the agent's system prompt (~50-100 tokens each); the full instructions load into context only when the agent calls load_skill.
Make
Unknown: no reusable cross-agent skill unit foundUnknown: No public Make documentation describes a feature for defining a reusable, named prompt or knowledge snippet once and invoking it by reference across multiple AI agents. Make AI Agents support per-agent context files (uploaded documents chunked into a RAG vector store) and a single system prompt/instructions field per agent, but nothing found indicates these are sharable, named, reusable units across agents.. Help Center pages on AI agent configuration and management describe per-agent context and instructions but do not mention a shared skill/snippet library across agents.
Native chat deployment
Sim
Make
No: Make AI Agents include a chat interface, but it is documented only as an internal testing/debugging tool for the builder to converse with an agent, not as a publicly deployable chat surface. Make has no native public chat widget or link for end users comparable to a hosted agent chat page. Agents are invoked from within scenarios via a 'Run an agent' module, or externally via channel integrations (Slack, WhatsApp, Telegram, Teams) built using Make's automation modules, or via the MCP server/API.. Make's own help pages ('Manage AI agents', 'Introduction to AI agents') describe internal agent management and a chat-based tester, with no mention of a public share link or embeddable widget for the agent itself.
Parallel execution
Sim
Yes: a native Parallel block fans a run out into concurrent branches (fixed count or one per list item) and joins their results back into the workflow automatically. Contained blocks run concurrently instead of sequentially, either a fixed number of times or once per item in a list/collection, and each branch's output aggregates for downstream blocks.
Make
No: Make's own Router documentation states routes are processed sequentially, not in parallel, so the second route does not run until the first has finished.. The Router module splits a scenario into multiple routes/branches, but Make's help center explicitly documents that these routes execute one after another rather than concurrently, so there is no native fan-out/fan-in concurrent branch execution.
Agent2Agent (A2A) protocol
Sim
Make
No: no documentation found of shipped Agent2Agent (A2A) protocol support; Make discusses A2A only as an emerging industry pattern, not a feature it has implemented.. Make's own blog lists A2A (agent-to-agent) alongside MCP as one of four communication patterns expected to matter in 2026, but states Make currently handles agent connectivity via its MCP server and client modules plus its app library, without mentioning A2A support.
Loop / iteration block
Sim
Make
Yes: Make has two dedicated Flow Control loop modules. The Iterator takes an existing array and outputs each element as a separate bundle, running every downstream module once per item, sequentially. The Repeater generates a fixed number of bundles from scratch (a numeric counter, no source array needed), also processed one at a time.. Per Make's Help Center, the Iterator splits an array into individual bundles that flow through the rest of the scenario one item at a time, while the Repeater runs a specified number of repetitions (its 'repeats' field) with each bundle carrying an incrementing counter item. Both are sequential, item-by-item execution; Make's separate Router feature (used for branching, not looping) is also documented as processing routes sequentially rather than in parallel.
Integrations
Integrations
Sim
1,000+ integrations (266 blocks, ~3,900 tool actions)1,000+ integrations counting individual API actions, built from 266 first-party blocks and roughly 3,900 underlying tool actions. Sim's landing page cites the "1,000+ integrations" figure; the block/tool-action counts are the same integration surface measured at a different level of granularity.
Make
3,000+ vendor-claimed integrations3,000+ apps (vendor-claimed). Make's integrations page (make.com/en/integrations) states '3,000+ Integration Apps.' Some 2026 reviews cite a lower '1,400+ apps' figure, likely a different counting method (apps vs. individual modules); the primary vendor page says 3,000+.
Trigger types
Sim
Webhook, cron, chat, REST API, 61 app triggers, plus a diff-aware Tables triggerWebhook, schedule/cron, chat, REST API, and event-based triggers for 61 apps (Slack, Gmail, GitHub, Stripe, etc.), plus a native row-level trigger on Sim Tables that fires on insert/update with an optional column watch-list and emits a before/after diff
Make
Instant webhooks, polling, and custom webhooksInstant/webhook triggers, scheduled (polling) triggers, and custom webhooks; app-event triggers via app-specific instant modules. Make supports app-specific 'instant' (webhook-based) triggers that fire in real time, scheduled/polling triggers (as low as 1-minute intervals on paid plans, 15-minute on Free), and generic custom webhooks that generate a unique HTTPS URL any external service can POST to, triggering the scenario.
Custom code steps
Make
Yes: native 'Make Code' module supporting JavaScript (Node.js) and Python, plus optional third-party packages on Enterprise. The Make Code app lets users write and run JS or Python inside a scenario execution with no external servers; common libraries (moment/lodash for JS, pendulum/toolz/requests for Python) are pre-installed, and Enterprise plans can import additional third-party packages as declared dependencies. Direct outbound API calls are technically possible, but Make recommends using the HTTP module instead to avoid exposing credentials.
API publishing
Sim
Yes: a public REST API (mostly under /api/, with /api/v1 reserved for logs and audit-log endpoints) supporting API-triggered workflow execution and deployment rollback. The API reference does not document SSE streaming, a resumable event buffer, a dedicated API-trigger block, or a chat-deployment surface as part of the REST API itself.
Make
Yes, via custom + response webhooks acting as API endpoints; plus a separate Make platform REST API. A scenario's Custom Webhook trigger generates a unique HTTPS endpoint; combined with a Webhook Response module, a scenario can receive a request, process it, and return a custom response, effectively publishing it as an API endpoint. Separately, Make exposes its own developer REST API (developers.make.com) for managing scenarios/hooks programmatically, distinct from publishing a scenario's own logic as a client-facing API/SDK.
SDKs & extensibility
Sim
Official Python and TypeScript SDKs, plus MCP, code block, and A2A protocolOfficial client SDKs exist for Python (simstudio-sdk, pip install simstudio-sdk) and TypeScript/JavaScript (simstudio-ts-sdk, npm install simstudio-ts-sdk), both wrapping the REST API (x-api-key header) with methods like execute_workflow / executeWorkflow, retry-with-backoff, and usage-limit lookups. Extensibility is further extended by MCP (client + server), a sandboxed code-execution block (JS/Python), custom tools, and an Agent-to-Agent (A2A) protocol block for external agent interop
Make
Apps SDK for custom connectors, no client SDKApps SDK (VS Code extension + browser Apps Editor) for building custom apps/connectors, plus a Make Marketplace for publishing them; no dedicated first-party Node.js/Python client SDK found beyond the general REST API. Make provides the 'Make Apps Editor', a JSON/config-based custom-app development environment available both as a browser-based editor inside Make's dashboard and as a VS Code extension (the Apps SDK) that syncs local files to Make via API. A custom app is built from five components: base, connections, modules, RPCs, and webhooks. Built apps can be submitted to the Make Apps Marketplace (beta), subject to a review process (roughly 4-6 weeks) and limited to services not already covered by Make's built-in app library. No official multi-language client SDK (published Node.js or Python packages) exists beyond the documented REST API; client access is via plain REST calls only.
Publish as MCP server
Sim
Make
Yes: Make MCP Server lets a Make account expose its scenarios as callable MCP tools for external AI clients (Claude, ChatGPT, Cursor, etc.) to call with structured inputs/outputs; scenarios must be set to active and 'on demand,' and access is via an MCP token. Make also offers MCP Toolboxes, team-level dedicated MCP servers exposing a curated subset of scenarios as tools, in addition to separately supporting an MCP client for consuming external MCP servers.. Included in all Make plans at no extra cost per Make's own MCP page; this is the reverse direction from Make's separate MCP Client app which consumes other MCP servers.
Observability & durability
Tracing & observability
Sim
Yes: execution logs include a per-block/per-span trace view (duration, cost, token counts, and latency stats like TTFT/TPS) with expandable nested iteration groups, plus a "View Snapshot" frozen copy of the workflow structure and block states at run time for debugging. This trace view is built directly into Sim rather than a raw export browsable in an external tool like Jaeger, and does not expose aggregate latency-percentile charts (p50/p95/p99). The run snapshot serves as a log-detail/debugging artifact rather than a resumable mid-run checkpoint.
Make
Per-run module tracing, no metrics dashboardPer-execution history with module-level bundle/output inspection and CSV export; no dedicated metrics dashboard (latency percentiles/error-rate charts). Make's Scenario History / Execution History is customer-facing and gives per-run detail: run date/time, trigger type, status (success/warning/error), duration, operations consumed, transferred data size, plus per-module bundles processed and module inputs/outputs/logs. Effectively span-like tracing at the module level for a given run. History is exportable as CSV, and full-text search across module outputs is available on Pro+ plans. No aggregate metrics dashboard (e.g. p50/p95 latency, error-rate trends across scenarios) exists; visibility is per-execution/per-scenario, not a fleet-wide observability dashboard.
Durability & retries
Sim
Tool-call retries (up to 10x); single-attempt job orchestrationIndividual tool/API calls have configurable exponential-backoff retry (up to 10 attempts). The background job-orchestration layer itself retries only once by design. Durability instead comes from consecutive-failure tracking on schedules and the human-in-the-loop snapshot pause/resume mechanism. Sim does not offer guaranteed-once-only block execution, a failed-run holding queue for manual recovery, or a "replay a past execution with its original inputs" feature. The per-execution debugging snapshot serves as a log-detail artifact rather than a resumable mid-run checkpoint.
Make
Auto-retry plus manual checkpoint replayAutomatic retry with exponential backoff for specific transient errors, checkpointed 'incomplete executions' that can be manually edited and replayed with original (editable) inputs. Make auto-retries incomplete executions caused by rate-limit errors, connection errors, and module-timeout errors, using exponential-backoff scheduling. Default 3 retry attempts with a 15-minute delay, configurable in the error-handler settings. When 'Incomplete Executions' is enabled (off by default) and a Break error handler fires, Make stores the erroring bundle plus the remaining flow as a checkpoint; the customer can then manually retry, edit the bundle data before retrying, or delete it. Replay-from-checkpoint is a supported, customer-facing capability, not fully automatic beyond the built-in retry policy.
Failure alerting
Sim
Make
Email alerts on failure, no usage-threshold alertsProactive email notifications when a scenario stops/errors or is auto-deactivated due to errors; no built-in cost/latency-threshold alerting. Make sends email notifications by default when a scenario encounters a warning/error or is automatically deactivated due to repeated errors, so customers are proactively notified rather than needing to check manually. Notification preferences are managed per-organization on the user's Profile > Email preferences page. Proactive cost/usage-threshold alerting (e.g. 75/90/100% of plan limit) is not currently a built-in capability. Only failure/deactivation alerting is confirmed.
Data drains
Sim
Yes: Enterprise orgs can continuously export workflow logs, job logs, or audit logs on a schedule to a customer-owned S3 bucket, GCS bucket, Azure Blob container, BigQuery table, Snowflake table, Datadog logs intake, or an HTTPS webhook. Each drain exports exactly one data source; multiple drains are created to export multiple sources. Viewing drain config/run history is restricted to org owners/admins.
Make
Unknown: no dedicated export/drain feature foundUnknown: Make has no documented built-in, continuous export pipe of execution/audit/usage data to an external destination like S3, BigQuery, or Datadog. Make exposes webhooks and an API that could be scripted to push data out, and White Label audit logs can retain up to 365 days, but there is no dedicated 'data drain' style continuous-export feature.. Users would need to build a scenario/API polling workflow themselves; this is different from a first-class continuous data-drain product feature.
Async execution
Sim
Yes: a workflow can be triggered in fire-and-forget async mode, returning HTTP 202 with a job ID immediately, then polled via a dedicated jobs endpoint through queued/processing/completed/failed states. Async jobs are tracked via polling the job endpoint rather than a completion webhook/callback option.
Make
Yes: Make scenarios triggered by webhooks or an MCP/API call run in the background rather than blocking the caller. Make's own docs state that even after a scenario-run tool call times out, the called scenario keeps running in Make for up to 40 minutes, and the caller can retrieve the output once it finishes. Make also keeps a persistent Executions log, plus an 'incomplete executions' safety store, that a caller can check later for run status and output.. Instant (webhook) triggers process requests as they arrive and return an immediate HTTP ack (default 200/400/429) while the scenario itself keeps running; the caller can poll the scenario's execution history or retrieve output afterward. This is documented explicitly for the MCP server tool-call flow, and the same instant-trigger/queueing model applies to webhooks generally.
Execution limits
Sim
5-50 min sync timeout, 90 min async, 10-1,000 concurrentPlan-gated: synchronous API calls time out at 5 minutes on the free plan and 50 minutes on paid plans, async calls at 90 minutes on every plan, with 10 to 1,000 concurrent executions per billing account depending on plan. Concurrency limits are published in the platform cost docs, and Enterprise limits are customizable. Request bodies are separately capped at 10 MB.
Make
25s/40s MCP call timeout; 40-min background run; no published module-timeout figureMake's MCP Server enforces a per-call timeout of 25 seconds (OAuth authentication) or 40 seconds (MCP token authentication) before returning a timeout response, after which the called scenario continues running for up to 40 minutes in the background. Make does not publish a general per-module/API-call timeout figure or documented concurrent-execution caps per plan tier; the commonly cited ~40-second module timeout is user-reported, not officially documented. Make lets admins cap how many instant-trigger scenario runs can start per minute, a configurable rate limit available on all plans, though no specific default number is published.. Per Make's MCP Server docs, the timeout before a timeout response is returned depends on the authentication method: 25 seconds for OAuth, 40 seconds for an MCP token; the called scenario itself keeps running in the background for up to 40 minutes. help.make.com/scenario-settings, sometimes cited for general module/API-call execution limits, does not document any timeout figure at all. Admins can cap instant-trigger scenario starts per minute via help.make.com/scenario-rate-limits-for-instant-triggers, but that page does not state a specific default numeric ceiling, and Make does not publicly document concurrent-execution-count limits per plan tier.
Partial-failure handling
Sim
Make
Yes: Make lets you attach an error handler route to any module. Directives such as Resume, Ignore, and Break let the scenario keep processing the rest of the run instead of the whole execution halting on one failed step. Resume substitutes a fallback value for the failed module's output and continues with the next module; Ignore logs the error and continues. Both skip only the failed item rather than stopping the entire scenario.. Make's error-handling model attaches a dedicated error route to a module; directives available include Resume (continue with substitute output), Ignore (continue, log only), Commit/Rollback (transaction-style), and Break (retry later via incomplete executions), giving fine-grained continue-vs-halt control per step rather than an all-or-nothing failure model.
Unattended execution
Sim
Yes: scheduled, webhook, and chat-triggered runs execute as background jobs on trigger.dev workers, entirely on Sim's servers. No client device needs to be open, awake, or connected for a run to fire or complete; closing the browser tab or shutting down a laptop has no effect on a scheduled or triggered workflow.
Make
Yes: Make is a fully managed multi-tenant SaaS running on Amazon AWS, so scheduled, webhook, and MCP-triggered scenarios execute entirely on Make's own servers with zero dependency on any client device staying open, awake, or connected.. Scenario execution happens on Make's AWS infrastructure regardless of trigger type (scheduled, instant/webhook, or MCP tool call); closing the browser tab or shutting down a laptop has no effect on a scheduled or triggered scenario. The only local component Make offers is an optional on-premise agent that bridges Make's cloud to a private network for connectivity, not a requirement for scenarios themselves to run.
Support
Support channels
Sim
Community support plus Enterprise 'Dedicated Support'Community (open source, GitHub) plus an unquantified "Dedicated Support" flag on the Enterprise plan. Enterprise and pricing pages do not include CSM, onboarding/enablement, or professional-services details beyond a plan-comparison-table "Dedicated Support" flag.
Make
Tiered support, 24/7 on EnterpriseTiered: community/basic support on Free, 'technical support from expert team' on Core/Pro, dedicated consultants on Teams, 24/7 senior-specialist support on Enterprise. Per Make's pricing page: Free gets '90-day expert access to get started'; Core and Pro get 'technical support from our expert team'; Teams gets 'high-priority guidance from dedicated consultants'; Enterprise gets '24/7 top-priority assistance from senior specialists' plus a Value Engineering Team and information-security compliance review support. Exact channel (email vs. chat vs. phone) is not specified on the page.
SLA
Sim
Make
99.5% uptime SLA, Enterprise onlyEnterprise plan states a 99.5% Cloud Service Uptime SLA with defined Customer Support Service SLAs. Make's Security page states the Enterprise plan carries a '99.5% Cloud Service Uptime' commitment along with defined Customer Support Service SLAs; exact response-time SLA numbers require a sales consultation and are not published on the page.
Community
Sim
100,000+ buildersOver 100,000 builders use Sim
Make
Active forum, no published member countUnknown exact size. Make Community forum and unofficial Facebook groups exist, but no publicly stated member count. Make operates an official community forum at community.make.com, and unofficial Facebook groups (e.g. 'Make.com (formerly Integromat) User Community') exist, but no official size figure (forum members, Discord, GitHub stars) is publicly published.
Academy / training
Sim
Make
Yes: Make operates a free, self-paced online learning platform called Make Academy (academy.make.com), with structured courses from Foundation through Advanced levels, bundles like Make Basics and Foundation, assessments, and Credly-verified digital badges/certifications.. Course enrollment gives 6 months of access; certification path can take about 15 hours across levels. Separate Make Partner Training portal also exists for partners.
Sim standout features
AI Copilot / Chat agent-building surface
Chat builds and manages work across the workspace; in-editor Copilot edits a single workflow.
A workspace-wide natural-language surface (Chat) that can build workflows, manage data, and take actions across integrations, plus an in-editor Copilot scoped to building and editing a single workflow directly.Hybrid semantic + keyword knowledge base
Combines vector and full-text search with configurable chunking across 11 file formats.
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).Native MCP client and server
Call external MCP servers as tools, or expose Sim workflows as an MCP server.
A dedicated MCP block lets any workflow call external MCP servers as a tool, and a serve/workflow-servers API surface lets Sim expose its own workflows as MCP servers.Fork a workspace into dev, qa, and prod environments
Fork, diff, and promote environments with mandatory credential remapping.
Fork a whole workspace into a dev/qa/prod-style child environment, preview a diff, and promote changes bidirectionally. Credential and env-var remapping is required on every promote, so secrets never cross environments silently.Human-in-the-loop approvals with durable resume
Pause a run for human approval and resume later via a durable snapshot link.
A dedicated block pauses a run and waits for a human-submitted approval form, backed by persisted execution snapshots so the run can resume later via a link, even after a server restart.Self-hostable under Apache 2.0
Fully open source with Docker Compose and Helm deployment options.
Fully open source (Apache 2.0), with Docker Compose files and a Helm chart for Kubernetes deployment, alongside a managed cloud-hosted option.Live multiplayer canvas editing
Real-time cursors, selections, and synced edits on the same canvas.
Real-time cursors, selection broadcasting, and synced concurrent edits over a dedicated realtime backend, so a team can build the same workflow together at the same time.Documented Make limitations
No self-hosting of the core platform
No self-hosted deployment; only a network-bridging on-prem agent.
Make is a fully managed multi-tenant SaaS; there is no option to run the Make engine itself on customer infrastructure. The only on-prem artifact is a lightweight 'agent' that bridges Make's cloud to a private network, not a self-hosted deployment of the platform.Proprietary, closed-source license
Closed-source codebase with no community fork or audit path.
Unlike open-source workflow tools, Make's codebase is not published; Celonis (Make's owner) retains exclusive ownership of the Services, and customers are contractually barred from copying, modifying, creating derivative works from, or reverse-engineering the platform, so there is no community fork/self-audit path and organizations depend entirely on Celonis's roadmap and infrastructure.Code step allows direct HTTP calls; custom package installs need Enterprise
Code step permits HTTP calls; custom package installs are Enterprise-only.
The native Make Code (JS/Python) module can make direct HTTP requests, though Make recommends using the dedicated HTTP module instead to avoid exposing credentials. Enterprise-plan customers can import custom third-party npm/PyPI libraries as declared dependencies; lower tiers only get Make's pre-installed common libraries.Granular RBAC gated to the Teams plan and above
RBAC needs the Teams plan ($38/mo) or above.
Full team/role-based permission management ('Teams and team roles', letting admins manage unlimited team permissions for scenario apps, templates, and connections) is only listed as a feature starting on the Teams plan ($38/mo) and Enterprise; lower tiers (Free, Core, Pro) get unlimited users but no role-based access controls, unlike Sim, which ships admin/write/read roles on every tier.Bottom line
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.
Choose Make if you specifically need 3,000+ integrations and an 8,000+ template gallery: Make lists 3,000+ integration apps and a public gallery of over 8,000 pre-built, importable scenario templates, free to browse on every plan including Free.
Frequently asked questions
Sim is an open-source AI workspace where teams build, deploy, and manage AI agents visually, conversationally, or with code. Make (make.com) is a closed-source, cloud-only visual workflow-automation platform where users connect app "modules" on a canvas into scenarios. It now also offers AI Agent blocks, an MCP server, and a JS/Python code step, billed on a per-module-execution credit model. 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.