🧭 Iterion and alternatives — feature matrix

🏢 10 products · ✅ 21 features at a glance · 🧠 12 agent workflow dimensions · 🗂 4 detailed topics.

Documentation reviewed on September 11, 2026.

📚 Explore Iterion in depth: 140 criteria across 16 categories, with sources, limitations and 35 bots. The common matrix covers 21 criteria; the inventory details the broader capabilities of Iterion's agent-centered architecture.

Quick navigation

✅ Feature availability · 🧠 Agent workflow depth · 🧩 Authoring & integrations · 🔄 Orchestration & budgets · 🛠 Technical environment · ☁️ Deployment & governance · 🏢 Team access

🎯 Choosing an architecture · 📚 Sources

👁️ Supervision · 🙋 Asynchronous interaction · 📚 Memory · ⏪ Recovery and files · 🧩 Plugins · ⚡ Triggers

✅ Feature availability

One feature per row, one product per column. Feature links open the technical explanations below.

✅ Yes · ❌ No within the reviewed scope · 🟡 Conditional or partial · 🛠 Integration to develop

“Yes” means the product supplies the feature with normal configuration; it does not imply free availability or equivalent scope. Yellow marks a material condition explained below. 🛠 identifies an explicit integration path that needs implementation and testing. Edition restrictions remain visible in yellow.

↔ Scroll to compare all ten products. Feature labels stay visible.

Feature	Iterion	n8n	Make	Zapier	Activepieces	Dify	Flowise 🗄 Archived	LangGraph	CrewAI	Windmill
🎨 Build visually without coding the graph	✅	✅	✅	✅	✅	✅	✅	🟡¹	🟡¹	✅
📄 Workflow definition available as a file	✅	✅	✅	🟡²	✅	✅	✅	✅	✅	✅
⌨️ Execute code within a workflow	✅	✅	🟡⁴	✅	✅	✅	✅	✅	✅	✅
🤖 AI agents that can call tools	✅	✅	✅	🟡²	✅	✅	✅	✅	✅	✅
🔌 MCP integration, client or server	✅	✅	✅	✅	✅	✅	✅	🟡¹	🟡¹	✅
🙋 Human intervention before continuing	✅	✅	🛠⁸	🟡²	✅	✅	✅	✅	✅	✅
💾 Persist and resume a human wait	✅	✅	🛠⁸	🟡²	✅	✅	✅	✅	✅	✅
🔀 Workflow branches and loops	✅	✅	✅	✅	✅	✅	✅	✅	✅	✅
💰 Run-level token budget	🟡³	🛠⁹	🛠⁹	🛠⁹	🛠⁹	🛠⁹	🛠⁹	🛠⁹	🛠⁹	🛠⁹
💵 Run-level estimated AI cost budget	🟡³	🛠⁹	🛠⁹	🛠⁹	🛠⁹	🛠⁹	🛠⁹	🛠⁹	🛠⁹	🛠⁹
🌿 Create a Git worktree for a mission	✅	🛠¹⁰	🛠¹⁰	🛠¹⁰	🛠¹⁰	🛠¹⁰	🛠¹⁰	🛠¹⁰	🛠¹⁰	🛠¹⁰
🔀 Finalize Git results with a merge policy	✅	🛠¹⁰	🛠¹⁰	🛠¹⁰	🛠¹⁰	🛠¹⁰	🛠¹⁰	🛠¹⁰	🛠¹⁰	🛠¹⁰
🛡 Isolate code execution in a sandbox	🟡⁴	🟡⁴	🟡⁴	🟡⁴	🟡⁴	✅⁴	🟡⁴	🟡¹	🟡⁴	🟡⁴
📁 Agent sandbox with shell and project files	🟡⁴	🛠¹⁰	🛠¹⁰	🛠¹⁰	🛠¹⁰	🟡¹³	🛠¹⁰	🟡¹	🟡⁴	✅⁴
⚙️ Distribute execution across your own workers	✅	✅	❌⁵	❌⁵	✅	🟡¹¹	✅	🟡¹	🟡¹¹	✅
🏠 Self-host the workflow engine	✅	✅	❌⁵	❌⁵	✅	✅	✅	✅	✅	✅
☁️ Managed hosting: available or assessed on request	🟡¹²	✅	✅	✅	✅	✅	🟡⁶	🟡¹	🟡¹	✅
🏢 Team/project access controls on your infrastructure	✅	🟡¹⁴	❌⁵	❌⁵	🟡¹⁴	🟡¹⁴	🟡¹⁴	🟡¹⁴	🟡¹⁴	🟡¹⁴
👥 SSO for team access	✅	🟡²	🟡²	🟡²	🟡²	🟡²	🟡²	🟡¹	🟡²	🟡²
📖 Publicly available engine source code	✅	✅	❌⁵	❌⁵	✅	✅	✅	✅	✅	✅
📜 Engine core under unmodified MIT or Apache 2.0	✅	❌⁷	❌⁵	❌⁵	✅⁷	❌⁷	✅⁷	✅	✅	❌⁷

📋 Conditions, scope and limitations

1. Frameworks and associated components. LangGraph defines graphs in code; LangSmith Studio visualizes and debugs them. Associated LangSmith Fleet builds agents without code, giving this broader product scope a conditional authoring cell. Fleet does not establish visual editing of an arbitrary LangGraph graph. L11 Deep Agents is an associated harness whose sandbox backends provide file tools and shell execution; a backend must be configured. L8 CrewAI has a visual platform Studio, including a free Basic tier, separate from its Python framework. Managed services, authentication and MCP adapters rely on associated components. L2 L3 L4 L7 C2 C9

2. Plans and editions. Zapier provides tool-using AI by Zapier steps from Professional, requiring an Advanced or Premium model even with BYOK. Human approval is available from Professional, with configurable expiration; JSON import/export requires Team/Enterprise. Dify and Flowise SSO require Enterprise, as do several controls in other products. Yellow cells reflect these restrictions. n8n Community supports user accounts but excludes shared projects, workflow/credential sharing, SSO and Git version control. Z6 Z8 Z11 Z5 N3 N12 M1 A8 D7 F6 C9 W9

3. Iterion budgets. Limits apply to the current run without aggregating sub-bots; default finalization headroom is 10%. Cost is estimated. A limit per LLM call or agent is not automatically a cumulative run budget. For other products, see the proposed integration in note 9. I1 W2 C5

4. Sandbox scope. n8n: Code runners; Make: JS/Python sandbox on paid plans; Zapier: isolated scripts with time/memory limits; Dify: restricted Code node (the new Agent sandbox is covered in note 13); Flowise: associated E2B interpreter. These code interpreters alone do not establish an agent environment with shell and project files. Iterion depends on the backend, Activepieces on mode, CrewAI on associated services and Windmill on configuration. I4 N5 M8 Z7 A5 D3 F7 C6 C13 W5 W6

5. Make and Zapier SaaS engines. “No” refers to the reviewed commercial engines, not SDKs or connectors. Make's on-premise agent connects its SaaS to a local network; it is not a standalone workflow engine. The Make self-hosting conclusion is inferred from this documented scope. Zapier explicitly states that it does not offer an on-premise version. M1 M5 Z4

6. Flowise end of life. Features describe the documented software. The repository was archived on August 13, 2026, with the core team's official Discord/GitHub presence ending August 31, 2026. The site still lists Cloud: 🟡 records that historical offering and its major limitation, without confirming new contract availability. F3 F9

7. Licenses. n8n uses the Sustainable Use License, Dify a modified Apache license, and Windmill a mixture of AGPL and Apache by file. Activepieces and Flowise checkmarks apply to community cores, excluding Enterprise components. Public source access and permissive licensing are separate criteria. N7 D6 W8 A7 F4

8. Human waits in Make. Proposed integration: store state in a Data Store, request a decision, then trigger a second scenario through a webhook. These building blocks are documented; this application-level integration does not natively suspend the same execution. M9 M10

9. Cumulative budget integration. 🛠 means developing a budget controller: route AI calls through a custom API/tool, propagate a run ID, aggregate usage and reject subsequent calls. This may replace a built-in AI step. Sources establish extension points; accounting, enforcement, parallel calls and recovery require integration work and were not tested here. Zapier also pauses above 75 tasks per run, a task-based safeguard rather than a token/USD budget. N10 M12 Z9 Z10 A9 A10 D9 D10 F8 L5 C10 W1

10. Git and project sandbox integration. 🛠 means Git scripts and/or an external execution service connected through commands, HTTP or custom tools. Implement the behavior marked 🛠: worktree creation and finalization policy, or a shell/file service where the selected product does not supply one. An existing sandbox still needs a defined Git delivery policy. A Git connector alone does not supply this lifecycle. Extension points appear in the details and methodology. N9 N10 M11 M12 Z10 A9 D9 F8 L5 C1 W1 W5

11. Worker scope. Dify documents Celery workers for streaming execution and resumes; non-streaming workflows remain in the API process in the described version. CrewAI documents an Enterprise private platform with replicated workers, separate from operating its Python library alone. D8 C11

12. Managed Iterion. Managed service on request — subject to assessment. Self-hosting is available; feasibility, scope, service terms and support commitments are defined during that assessment.

13. Dify new Agent. The beta agent has a sandbox with commands, files and package installation. Its workflow node is available in Workflow apps; nodes do not automatically share sandbox state. This is separate from the restricted Code node. D11 D12

14. Self-hosted team access. This criterion covers supplied team/project resource access controls, including paid platforms explicitly identified below. It does not equate project sharing with organization-level multi-tenancy or workload isolation. Windmill Community is limited to three workspaces. See team access and multi-tenancy for every product's boundary and edition.

Cell evidence: the four detailed tables below describe each product's capabilities and official references. No “no” is inferred solely from an omitted mention. 🛠 paths are proposed architectures based on documented extensions. Methodology and status evidence.

---

🧠 What agent support actually covers

Iterion's agent-centered design spans the workflow engine, execution backends and shared platform. Use these dimensions alongside the availability grid: two products can both support “agents” while assigning very different work to the application developer.

Dimension	What Iterion provides	What to compare in your project
🧠 Execution backends and models	In-process claw plus Claude Code, Codex, pi, Kimi and Grok backends; selection per node. B01–B04	Model API selection and delegation to a coding-agent harness are different capabilities. Compare tools, session support, fallback and authentication for the exact backend.
🔀 Custom and adaptive orchestration	Reusable groups, sub-bots, parallel branches, data-dependent routing and loops; optional dynamic sub-agent orchestration inside supported nodes. O04–O09, B11	Decide which boundaries the graph owns and which decisions agents make at runtime. Check resource contention and child-run behavior.
🔁 Iteration and termination	Fixed or data-resolved loop bounds, plus explicit unbounded loops governed by fuel and a stagnation monitor. O06	Separate graph iteration limits from an agent's internal tool loop; test completion, exhausted fuel and lack of progress.
💬 Session and context control	Fresh/inherited/forked sessions, node session persistence, artifact-only handoffs and compaction, subject to backend support. B05–B08	Check what is carried between steps and iterations, what gets discarded, and how much repeated context costs.
👁️ Supervision during execution	Supervisor agents observe work and inject guidance; monitors have cadence and evaluation budgets. S01–S04	A post-run evaluator or parent delegating a task is different from a supervisor guiding a worker while it runs. Verify supported attachment and sub-bot paths.
🙋 Human collaboration	Approval forms, asynchronous questions, answer synchronization, steering and review dialogue. H01–H09	Check whether the agent can continue while a person answers, where it must stop and how the wait is persisted.
📚 Memory and knowledge	Document memory across runs with seven visibility scopes, selective context loading, import/export and optional auto-memory. M01–M07	Distinguish conversation history, workflow checkpoints, reusable knowledge and RAG ingestion/retrieval. Verify tenant boundaries and child-run access.
🧩 Reusable methods and integrations	Versioned .bot/.botz, presets, skills, plugins, scripts, MCP client/server, local connector actions and API/SDK. A01–A05, X01–X09, D04	Check what a package includes, which dependencies it needs and how to connect existing tools. A ready-made application connector and a programmable API are different integration efforts.
⏪ Recovery and debugging	Graph checkpoints, eligible-state resume, local file snapshots, rewind and verified actions. R01–R10	Test graph state, session state, files and external effects separately. Check which artifacts survive the selected deployment's failures.
🌿 Repository delivery	Worktrees, result inspection, review gates and explicit Git finalization policy. Repository targeting can also be optional or disabled. G01–G07	Separate versioning the automation from isolating and integrating an agent's code changes. Use non-repository tasks when Git is irrelevant.
🏢 Shared operations	Organizations, teams, roles, SSO, user/organization credentials, quotas, audit, triggers, scheduling and board dispatch. E01–E10, T01–T09, K01–K07	Compare multi-tenancy with multiple user accounts, and check what is included in the self-hosted edition. Match shared control-plane access with the actual execution isolation.
🔐 Controls and evidence	Static graph diagnostics, typed compute outputs, backend-dependent permissions, budgets, secrets, run artifacts and evaluation recipes. A08, O03, P01–P09, U01–U11, D05–D06	Verify what the runtime enforces: general output validation is not enabled by product entry points in the reviewed build, permissions do not cover every shell path, and child-run budgets remain separate.

Compare implementations at the same level. LangGraph is also an agent-oriented runtime; Deep Agents adds a harness with sandbox backends. Dify's new Agent includes a command/file sandbox in beta. Make and Windmill document conversational memory; Windmill also provides reusable and nested agents. These capabilities make session scope, supervision, deployment and the remaining integration work more informative than an “AI-native” label alone. L1 L8 D11 M15 W2

Reading the product details

✅ Native	🔌 Extension	🛠 Integration	🏷 Plan
Supplied by the product; configuration may be required.	Associated component.	Implementation using documented extension points.	Depends on edition or contract.

In the detailed tables, products are rows and each column asks the same question of all ten solutions. A cell may combine several conditions.

Compare scope and effort. A documented capability and a proposed integration can differ in coverage, effort and reliability. 🛠 describes the path supported by this study; it does not rule out another native solution.

🧩 1. Authoring, agents and integrations

Build workflows, customize agents and connect tools.

Product	🎨 Visual authoring	📄 Workflow definition / portability	⌨️ Deterministic code	🤖 Agents and models	🔌 Integrations and MCP
Iterion	✅ Native Studio	.bot sources, .botz bundles	Tool and compute nodes, commands, local connector action: nodes I8	Native agent/judge nodes, per-node backends/models, sessions, context and supported dynamic sub-agents	Forges, plugins, MCP client/server; local OpenAPI/Swagger connector packages, with broader catalog coverage and cloud transport still to extend I1 I2 I8
n8n	✅ Native editor	Native JSON export; Git versioning 🏷 plan-dependent	JavaScript / Python	Agents, multi-agent and model selection	Application catalog; inbound and outbound MCP N1 N2 N3 N8
Make	✅ Scenario editor	JSON blueprint export	Make Code: JavaScript / Python	Make AI Agents, conversation history and knowledge files M15	Application catalog; MCP client for AI Agents and Make server M1 M2 M3 M6 M7
Zapier	✅ Zap editor	Zap JSON export/import 🏷 Team/Enterprise Z6	JS/Python steps	AI by Zapier with tools 🏷 Professional+, Advanced/Premium model; Agents moving into Zaps Z11	Application catalog and MCP service Z1 Z7 Z9
Activepieces	✅ Flow editor	Flows and project releases	TypeScript steps	Run Agent steps and AI providers; standalone Agents/Chat are edition-scoped A12 A8	Pieces, connections and MCP A1 A2
Dify	✅ Native Studio	YAML DSL export	Python / JavaScript Code node	LLM/Agent nodes; new sandboxed Agent in beta D11 D12	Tools, plugins; documented MCP publishing D1 D2 D3
Flowise 🗄 Archived	✅ Assistant, Chatflow, Agentflow	JSON export/import; integration API/SDK F5	Custom JavaScript function	Agents, models and vector databases	Tools and MCP in AgentFlow V2 F1 F2
LangGraph	🔌 Fleet for no-code agents; Studio for debugging code-defined graphs L11	Graph in application source code	Host-language functions	Native agent orchestration; models/tools through code or LangChain; associated Deep Agents harness L8	MCP adapters through the LangChain ecosystem L1 L2 L3
CrewAI	Code framework; platform visual Studio, including free Basic	Python and agent/task configuration	Python functions and tools	Specialized agents, Crews and Flows	Tools, MCP through crewai-tools C1 C2 C9
Windmill	✅ Flow and app editor	Scripts, flows and YAML definitions	Multiple languages including Python, TS, Go and Bash	AI Agent steps, reusable/nested agents and conversation memory	Scripts/connectors; streamable HTTP MCP for agents W1 W2

📦 Portability between engines. An exported definition supports backup and review; running it in another engine requires adaptation. Exports may omit secrets, data or dependencies. D2 M2

🔄 2. Orchestration and execution control

Route steps, involve people, resume work and control consumption.

Product	🔀 Loops and routing	🙋 Human intervention	💾 Persistence and recovery	📐 Structured inputs / outputs	💰 AI budget controls
Iterion	Rules/LLM routing, fan-out, data-driven loops and supported dynamic sub-agents	Human nodes, asynchronous questions, steering and live supervision	Graph checkpoints; eligible-state recovery; backend-dependent sessions	Static graph checks and typed compute outputs; general runtime output validation is not enabled I7	Tokens, estimated cost, duration, iterations; excludes sub-bots, with default finalization headroom I1 I3
n8n	Flow control and agent composition	Tool-call approvals	Wait persists waits; not universal crash recovery	Structured inputs/outputs for AI steps	Max Iterations per agent; 🛠 run counter and enforcement in an HTTP AI service N1 N2 N4 N10 N11
Make	Routers, filters and iteration	🛠 Data Store + decision + webhook	Business state across two scenarios; separate incomplete executions and retries	Named, typed scenario inputs/outputs	Platform credits; 🛠 run budget through an HTTP AI service M1 M4 M9 M10 M12 M13
Zapier	Paths, filters and Looping	Human in the Loop 🏷 Professional and above	Wait until decision/expiration; separate error replay	Typed inputs and structured AI by Zapier outputs	Pause above 75 tasks/run; 🛠 token/USD budget through an external AI API Z1 Z2 Z8 Z9 Z10
Activepieces	Branches, loops and sub-flows	Approvals and waitpoints	Durable waitpoints survive worker restarts	Action properties; 🛠 overall contract validation in a Code step	Supported AI gateways; 🛠 per-run accounting and enforcement to integrate A1 A3 A4 A9 A10
Dify	If/Else, Iteration and Loop	Human Input node	Persisted human pause/resume within documented recovery mechanisms	Declared Code outputs; structured LLM outputs depend on model	Per-model settings; 🛠 token/cost counter and enforcement through AI plugin/API D3 D4 D5 D9 D10
Flowise 🗄 Archived	Branches, shared state and bounded Loop	Human Input node; tool approval	Human-wait checkpoints and recovery after restart	Flow state and schema-based LLM JSON; overall validation to compose	Loop/context limits; 🛠 cumulative budget through an AI tool/API F2 F8
LangGraph	Cycles, conditional routing and parallel branches	Interrupts and state editing	Checkpointers; persistent backend required	Graph state schema; business validation to build	🛠 Shared state counter and checks before AI calls L1 L4 L5
CrewAI	Event-driven Flows, routing and tasks	Human input; async feedback provider with notification/callback transport to implement C14	@persist, checkpoints and automatic persistence of pending human feedback C14	State models and structured outputs by configuration	Per-agent max_iter, duration/rate; 🛠 shared counter and LLM hook enforcement C1 C3 C4 C5 C10
Windmill	Flows with branches, errors and agent steps	Suspend / Approval; forms 🏷 Cloud or Enterprise	Suspension and step retries; agent state can use a volume	AI Agent output JSON Schema	Per-agent iteration and completion limits; 🛠 cumulative budget in an AI script/API W1 W2 W3 W4

🔎 Validate on your workflow: parallel execution semantics, recovery during an interrupted call and the correctness of generated content beyond schema validation.

💰 Iterion budget scope. Budgets are native, but sub-bot totals are separate from the parent's budget. Default finalization headroom is 10% and can be disabled. Cost accounting depends on backend information. Include these settings when measuring total mission cost. I1

🛠 3. Technical environment and repository work

Isolate execution, manage Git, prepare dependencies and inspect work.

Product	🛡 Code / agent isolation	🌿 Git worktree and result finalization	📦 Runtime dependencies	⚙️ Distributed execution	🔭 Technical observability
Iterion	Docker/Podman/Kubernetes drivers; behavior depends on backend and launch	Native worktree: auto, branch and merge policy	Bot + repository Devbox; sandbox images	Platform: NATS, runners, KEDA, MongoDB/S3	Events, artifacts, live console, session views, Prometheus and OTLP I2 I4 I5
n8n	External task runners for Code; 🛠 external service for per-mission shell/repository N10	🛠 Git scripts through self-hosted Execute Command, or HTTP service N9 N10	Extensible runner image; explicitly allowed packages	Queue mode: Redis, shared database and workers	Execution history, worker metrics; log streaming 🏷 plan-dependent N3 N5 N6
Make	Make Code JS/Python sandbox 🏷 paid; 🛠 external shell/repository service	🛠 Remote Git scripts through SSH or HTTP M11 M12	Standard libraries; custom libraries 🏷 Enterprise M8	SaaS engine; separate local connection agent	History, log search and audit 🏷 plan-dependent M1
Zapier	Isolated code, plan-dependent time/memory; 🛠 external shell/repository service	🛠 Git executor API called through Webhooks Z10	Code runtime; Git toolchain in external service Z7	SaaS engine, without self-hosted engine workers	Zap History; observability 🏷 plan-dependent Z1 Z2
Activepieces	V8 and/or namespace modes; 🛠 external shell/repository service	🛠 Git/sandbox executor through an HTTP-client piece A9	Piece versions and dependencies; npm depends on sandbox mode	App, Redis queue, workers and storage	Runs, analytics and audit 🏷 plan-dependent A1 A5 A6
Dify	Restricted Code sandbox; new Agent command/file sandbox in beta D11	🛠 Git tools and finalization policy; new Agent can execute commands, or use HTTP/plugin D9 D12	Code: predefined libraries; new Agent: package installation D11	Celery for streaming and resumes; non-streaming in the API in the described version D8	Logs, dashboard and tracing integrations D1 D3
Flowise 🗄 Archived	Associated E2B interpreter; 🛠 external shell/repository service F7	🛠 Custom tool calling a Git/sandbox executor F8	Libraries available to JS runtime; hosting configuration	Documented message queue and workers	Traces, analytics and evaluations F1 F2 F3
LangGraph	🔌 Deep Agents sandbox backend for shell/files; separate from graph runtime L8	🛠 Git functions/tools and finalization lifecycle to build	Application environment; sandbox backend/image when using Deep Agents	🔌 Agent Server / LangSmith deployment, or own operations	State streaming; LangSmith Studio, tracing and evaluations L1 L2 L4
CrewAI	Associated E2B execution/file tools; legacy CodeInterpreterTool deprecated C13	🛠 Python Git tools and finalization lifecycle to build	Python environment and selected tools	Team-operated framework; Enterprise private platform with replicated workers C11	Events and tracing integrations; console 🏷 plan-dependent C1 C6 C7 C9
Windmill	NSJAIL and namespaces; AI Sandbox with persistent volumes	🛠 Git scripts and merge policy in flows; AI Sandbox for files	Script dependencies; documented Python resolution and lockfile	Worker fleet, groups and access separation	Job logs, flow state and monitoring interfaces W1 W5 W6 W7

🛡 Compare sandbox boundaries. An isolated Python node, an agent sandbox with shell access and a platform pod protect different resources. n8n documents external Code runners; Dify separates restricted Code from its new Agent sandbox; Deep Agents supplies sandbox backends alongside LangGraph; Windmill has an AI Sandbox. Compare file lifetime, network access and recovery for the selected mechanism. N5 D3 D11 L8 W5

Iterion's auto mode can fall back to unsandboxed execution depending on the host; an explicit sandbox request behaves differently. The documented cloud path currently uses the runner pod as its isolation boundary. Codex delegation does not support Iterion's external sandbox. I2 I4

☁️ 4. Deployment, operations and governance

Choose hosting, interfaces and team controls. Iterion's self-hosted platform includes multi-tenant organizations, teams and roles; evaluate these separately from simple user login support.

Product	☁️ Self-hosting / managed service	⚡ API and triggers	🌿 Git for workflow lifecycle	👥 Team governance	📜 License / commercial scope
Iterion	Local and self-hostable platform; managed service on request — subject to assessment	CLI/SDK, API, cron, dispatcher, webhooks	.bot in Git; bundles and versions	Native multi-tenant organizations/teams, roles, SSO, bound secrets, quotas and audit	MIT; experimental status I2 I5 I6
n8n	Self-hosting and n8n Cloud	API, CLI, triggers and webhooks	Git/environments 🏷 plan-dependent	Community: user accounts, without shared projects or workflow/credential sharing; SSO and advanced governance 🏷 plan-dependent	Sustainable Use + separate Enterprise license N1 N3 N7 N12 N13
Make	SaaS; local connection agent, no standalone engine in the reviewed offering	API and scheduled/triggered scenarios	JSON blueprints; 🛠 Git/CI pipeline with Make CLI M14	Teams and Enterprise features 🏷 plan-dependent	Commercial service; credit quotas M1 M2 M5
Zapier	SaaS; no on-premise version	Triggers, webhooks and developer tools 🏷 plan-dependent	JSON export 🏷 Team/Enterprise; Git archiving and redeployment to arrange Z6	Workspaces, connections and controls 🏷 plan-dependent	Commercial service; task allocation Z1 Z4
Activepieces	Cloud and own infrastructure	Triggers, webhooks and MCP tools	Git and release promotion when Environments is enabled in the plan	Paid projects and roles; advanced audit/secrets 🏷 plan-dependent A11	MIT core; separate Enterprise components A1 A2 A7
Dify	Cloud, VPC and self-hosting	Application API; MCP publishing	YAML DSL export; Git pipeline to arrange	Community: one workspace; multiple workspaces, SSO and advanced governance 🏷 Enterprise D7	Modified Apache 2.0 with additional conditions D1 D2 D6
Flowise 🗄 Archived	Self-hosting; Cloud still listed; repository archived, official community presence ended F9	API, SDK and embedded chat	Versionable JSON exports; 🛠 Git pipeline to arrange F5	Teams/workspaces; OIDC SSO 🏷 Enterprise F6	Apache 2.0 core; separate commercial components F1 F3 F4
LangGraph	Self-operated library; associated LangSmith deployment	Runtime calls; API through Agent Server	Application code in the team's Git	Application-defined authorization; associated LangSmith Enterprise RBAC L9	MIT runtime; separate service terms L1 L2 L4 L6
CrewAI	Self-operated framework; Basic/Enterprise cloud platform	Python calls; platform deployments and triggers	Code and configuration in Git	Platform console; Enterprise SSO and RBAC	MIT framework; separate platform C1 C7 C8 C9
Windmill	Self-hostable; cloud offering	API, webhooks, scheduler and CLI	Git sync 🏷 Cloud/Enterprise; Community for workspaces up to two users W12	Workspace roles and item ACLs; Community limit of three workspaces W10 W11	AGPL/Apache by file; distinguish Enterprise and distributed binaries W1 W6 W8

🏢 Team access and multi-tenancy

Iterion includes organizations, teams and their access controls in its self-hosted platform. Compare this with the exact edition and resource boundary of each alternative. A shared login, a shared folder and an organization boundary cover different needs.

The availability row checks team/project access controls on infrastructure you operate. The table also records SaaS collaboration for context; Make and Zapier remain “no” for that self-hosted criterion.

Product	Team and resource boundary	Access conditions
Iterion	Organizations, teams and roles; tenant-scoped resources, credentials, quotas and audit.	Included in the self-hosted platform. Execution isolation still depends on runner and sandbox configuration. I5
n8n	Projects group workflows and credentials with project roles.	Paid projects and sharing; Community has user accounts but excludes these collaboration features. This does not establish independent organization tenants. N12 N14
Make	Teams own scenarios, connections and data within an organization.	Multiple teams and team roles require Teams or above; hosted engine. M16
Zapier	Shared folders grant collaboration access; workspaces separate users, Zaps, connections and task allocations.	Folder sharing: Team/Enterprise. Multiple workspaces: Enterprise; hosted engine. Z12 Z13
Activepieces	Projects scope flows, connections and tables to their members.	Projects are a paid feature; platform administrators and operators retain wider access. A11
Dify	Workspaces group applications, knowledge and members.	Self-hosted Community: one workspace. Multiple workspaces and enterprise management require Enterprise. D7
Flowise 🗄	Workspaces partition resources with workspace roles.	Cloud/Enterprise feature; self-hosted use requires Enterprise. The end-of-life condition applies. F10 F9
LangGraph	Associated LangSmith provides organizations, workspaces and RBAC.	RBAC and self-hosted LangSmith require Enterprise. These platform controls are separate from the graph library and application authorization. L9 L10
CrewAI	Associated private platform provides organizations and permissions; optional namespaces separate organization workloads.	Enterprise platform, separate from the Python framework. Namespace isolation needs explicit setup. C11 C12
Windmill	Workspaces scope users and resources; roles and item-level access control govern collaboration.	Community supports workspaces with a global limit of three; advanced controls and Git deployment depend on edition. W10 W11 W12

Check the boundary your application needs. These are platform access controls for builders and operators. They do not automatically provide end-user authorization, isolated networks or a sandbox per customer. Administrators may retain cross-workspace access. For Iterion, validate tenant configuration, bound secrets and execution isolation together.

🌿 Two different Git lifecycles. One versions and reviews the automation itself. The other isolates an agent's repository changes, preserves the result and determines how to integrate it. A GitHub connector or Git export alone does not establish the latter.

LangGraph and CrewAI are compared as frameworks, with associated platforms explicitly identified. Managed-service features are not automatically attributed to the open-source library; Enterprise features are not automatically attributed to community editions.

🗄 Flowise end of life: August 31, 2026. The repository was archived August 13. Software features remain documented; the Cloud listing does not guarantee current service or support. Official announcement.

🎯 Why Iterion's integrated approach matters

Iterion is AI-centric by design: agent and judge nodes, sessions, context, supervision and correction loops sit within the workflow engine. Developers can combine these primitives with custom scripts, plugins, MCP and APIs, then use the same platform for repository work, budgets, recovery and multi-tenant operations. The architectural choice is how much of that lifecycle you want supplied by the engine and how much you want to implement in application code.

Evaluate a complete mission: integration effort, execution behavior, accepted output and total cost, including models, infrastructure and human review. Feature counts cannot capture these tradeoffs; proposed 🛠 integrations need implementation and testing.

Try the full lifecycle on a real mission.

Get started with Iterion · Explore the bot catalog · Plan your pilot

📚 Official sources

Product logos and icons: visual asset provenance.

Iterion references are pinned to commit bbc1ddc7844b81582b6dfc4d0b7f381680bb284b, except the local connector foundation I8, reviewed at 603d2a1e3314252dd2995e3bfaa4a7394e13093b. Other sources were reviewed on September 11, 2026. CrewAI documentation displays version v1.15.21; its CodeInterpreterTool page announces deprecation while retaining historical examples, which are excluded from current capabilities here.

• Iterion: I1 — DSL; I2 — current state; I3 — recovery; I4 — sandbox; I5 — platform; I6 — license. Additional detail: I7 — output validation scope; I8 — local connector foundation. More: worktrees and merge, observability, planned catalog.
• n8n: N1 — documentation; N2 — agents and controls; N3 — recorded plan conditions; N4 — Wait; N5 — task runners; N6 — queue mode; N7 — license; N12 — Community scope; N13 — user management.
• Make: M1 — recorded plan conditions; M2 — blueprints; M3 — AI Agents; M15 — agent memory and knowledge; M4 — incomplete executions.
• Zapier: Z1 — recorded plan conditions; Z2 — replay; Z3 — Human in the Loop; Z11 — AI tools and access conditions.
• Activepieces: A1 — documentation; A2 — releases and Git; A3 — flow control; A4 — MCP tools and flow structure; A5 — sandboxing; A6 — architecture; A7 — license.
• Dify: D1 — documentation; D2 — applications and DSL; D3 — Code; D4 — Human Input; D5 — LLM; D6 — license; D11 — new Agent; D12 — Agent node scope.
• Flowise: F1 — introduction; F2 — AgentFlow V2; F3 — Cloud record; F4 — license.
• LangGraph: L1 — runtime; L2 — LangSmith Studio; L3 — MCP adapters; L4 — persistence; L10 — self-hosted platform; L5 — Graph API; L6 — license; L8 — Deep Agents sandbox backends; L11 — Fleet no-code authoring.
• CrewAI: C1 — concepts; C2 — MCP; C3 — checkpoints; C4 — human control; C5 — agents; C6 — CodeInterpreterTool deprecation; C7 — framework and platform; C8 — license.
• Windmill: W1 — platform; W2 — AI Agents; W3 — approvals; W4 — retries; W5 — AI Sandbox; W6 — isolation; W7 — Python dependencies; W8 — licenses.

Additional checks: n8n — JSON export; Make — on-premise agent; Zapier — support statement on on-premise; Zapier — SSO setup; Activepieces — SSO; LangSmith — authentication; CrewAI — Studio plan conditions; Windmill — SSO.