Why Heym

Heym is an AI-native automation platform. While n8n, Zapier, and Make.com started as trigger-action workflow tools and later layered in AI capabilities, Heym is built from the ground up around LLMs, agents, and intelligent automation. AI is not a node you bolt on—it is the core execution model.

AI-Native vs AI as an Add-On

Footnotes: ¹ Zapier Knowledge Sources — no exposed vector store or embedding control. ² Make.com has Pinecone/Qdrant modules but no native RAG node. ³ n8n AI Workflow Builder is cloud-only beta with credit caps. ⁴ n8n shows intermediate steps; full tracing requires third-party tools. ⁵ n8n supports AI tool-call approvals through chat, email, and collaboration channels, but it doesn't snapshot and resume the whole execution the way Heym does. ⁶ Zapier Human in the Loop supports approvals and data collection inside Zaps, but it isn't a public-review, snapshot-resume checkpoint system. ⁷ Make.com offers Human in the Loop as an Enterprise app with review requests and adjusted/approved/canceled outcomes, but it remains plan-limited and less agent-native. ⁸ n8n ships a dedicated Guardrails node, Zapier ships AI Guardrails across its AI products, and Make.com documents agent rules plus review flows but not a comparable standalone guardrails feature, so Make is marked limited. ⁹ n8n executes sequentially by default; parallelism requires sub-workflow workarounds. ¹⁰ Sustainable Use License — free to self-host for internal use, commercial redistribution restricted. ¹¹ As of April 22, 2026, n8n's official docs describe HTTP batching and loop/wait patterns rather than a native LLM batch-status branch, Zapier's official ChatGPT app docs list no triggers and only a generic API Request beta, and Make's official OpenAI integration page exposes batch actions like create/watch completed but not a first-class status-branching LLM node, so n8n/Make are marked limited and Zapier is marked unavailable for this specific workflow pattern. ¹² n8n's official docs cover HTTP Webhook and HTTP Request nodes plus Code/custom/community extensibility, but I couldn't find a first-party WebSocket trigger/send node, so n8n is marked limited. ¹³ Zapier's official docs cover inbound webhooks and outbound webhook/API requests over HTTP only, not native WebSocket trigger or send steps. ¹⁴ Make's official docs cover Webhooks modules and HTTP(S) request modules, but I couldn't find a native WebSocket trigger or send module. ¹⁵ n8n has no native LLM token cost tracking; community workaround workflows exist but require manual installation and post-execution API calls (open feature request as of May 2026). Zapier exposes no per-execution token count or USD cost to users; AI steps consume tasks only. Make.com's credits dashboard partially reflects token consumption for Make-hosted AI (since August 2025) but third-party API key connections are billed as 1 operation = 1 credit with no token counting; no per-execution USD breakdown by model is available. ¹⁶ Heym emits native OpenTelemetry spans (one per workflow run plus one per node) over OTLP/HTTP to any compatible backend, with W3C trace-context propagation and no instrumentation code, configured via HEYM_OTEL_* env vars and disabled by default. n8n has a documented OpenTelemetry tracing integration for workflow and node executions. Zapier and Make.com do not document OpenTelemetry export of their workflow/scenario executions as of June 2026. ¹⁷ n8n documents an Insights dashboard for production execution metrics, Zapier documents Zap History plus Task Usage, and Make.com documents Scenario History; these are monitoring/history surfaces, not custom dashboard widgets backed by arbitrary workflow logic like Heym's Dashboard tab. ¹⁸ Heym Workflow Analyzer runs the workflow when possible, reads the execution result, and generates a shared editable Markdown report covering improvement areas, purpose, and step-by-step behavior. n8n documents AI Workflow Builder for creating/refining/debugging workflows, Zapier documents AI troubleshooting for errored Zap runs, and Make.com documents scenario history plus AI agent reasoning steps, but their public docs do not describe the same run-aware shared workflow analysis document. ¹⁹ n8n All executions lists running executions and can load data from a previous execution into the editor, while Zapier run statuses exposes a running state in its editor. Make Scenario History documents run detail and logs. Their public documentation, checked July 18, 2026, does not describe Heym's exact flow: open an arbitrary in-flight production run from History or a Kanban card, restore its current node snapshot, and continue receiving node animation and Debug logs on the same canvas. ²⁰ Heym's Codex and OpenCode Go nodes run a real coding agent CLI in an isolated Heym workspace against a GitHub repository — clone, edit, produce a diff, push a branch, open a pull request — as a first-class workflow step. As of July 20, 2026, no competitor documents an equivalent: n8n's OpenAI node covers chat/assistant API calls, not a repository-level coding agent, and native Codex support remains a community request; Zapier's own blog documents the reverse direction — Codex driving Zapier tools through Zapier MCP — not Codex as a Zap step; Make.com's OpenAI modules expose completions/assistants/batch actions, not a coding agent that clones repos and opens PRs. ²¹ Heym's Board tab is a built-in agentic Kanban board whose columns execute workflows and whose cards carry context, conversation history, execution state, and runs. n8n (Kanban Tool integration), Zapier (Kanban Tool integrations), and Make.com (Kanban Tool integration) only connect to third-party kanban apps such as Kanban Tool, Wekan, or NocoDB; none documents a built-in board that runs its own workflows, as of July 20, 2026. ²² n8n stores execution binary data internally (optionally on S3-compatible external storage) but documents no user-facing file drive with share links or team sharing, so it is marked limited. Zapier's Files by Zapier processes files only for the duration of a Zap run and Storage by Zapier holds small text values, so Zapier is marked limited. Make.com's data stores hold structured records and its file handling passes files between apps without persistent built-in storage, so Make is marked unavailable. ²³ Heym's Playwright node is first-party browser automation with a visual steps mode, AI-generated steps, and a full-code mode. n8n offers only community packages such as n8n-playwright with a still-open feature request for native browser automation nodes, so it is marked limited. Zapier Agents can browse and read pages via web browsing and a Chrome extension but Zapier documents no scripted browser automation step, so it is marked limited. Make.com documents HTTP modules and third-party scraping apps rather than any native browser automation module, as of July 20, 2026.

Built-In LLM and Agent Nodes

All major platforms now have LLM and agent nodes, but Heym's Agent Node goes further with a tightly integrated tool-calling loop, inline Python tools, MCP connections, and a portable skills system—all designed for production AI workflows.

Heym's plain LLM node also goes beyond a single prompt-response step. For supported OpenAI and OpenAI-compatible endpoints, it can switch into Batch API mode so one node submits an array of prompts in a lower-cost provider-native batch request. The canvas then exposes a dedicated batchStatus branch that fires as the batch moves through states such as pending, processing, and completed.

That means the LLM node can do two things at once:

• Run the main batch request and return the final per-item outputs on the normal branch
• Fire notification or logging logic on every meaningful batch status update without turning the flow into a custom polling loop

Other tools can approximate parts of this with generic HTTP modules or polling patterns, but Heym makes it a first-class LLM workflow primitive with provider/model capability checks in the node UI.

The Agent Node is the core differentiator:

• Tool calling – The agent iterates over tool calls in a loop until it produces a final answer
• Python tools – Define custom tools inline with full Python; the agent calls them at runtime
• MCP connections – Connect to any Model Context Protocol server (stdio or SSE) and the agent gets all its tools automatically
• Skills – Drop a .zip or .md file onto an agent to extend its system context and add Python tooling
• Sub-workflow calls – The agent can invoke other Heym workflows as tools, composing complex behavior without custom code

See Agent Node and Agent Architecture for the full reference.

Multi-Agent Orchestration

Heym supports an orchestrator pattern with first-class visual primitives that other platforms lack:

• One agent acts as the orchestrator (isOrchestrator: true) and is given a call_sub_agent tool
• It delegates tasks to named sub-agents on the same canvas
• Sub-agents can themselves call other agents or sub-workflows (max depth: 5)
• Parallel execution: When the orchestrator calls multiple sub-agents in one turn, they run in parallel for faster results

This enables architectures like a planning agent that routes work to a researcher, a coder, and a summarizer—all wired visually, without custom orchestration code.

See Agent Architecture for execution details.

Coding Agents as Workflow Nodes

Heym ships two nodes that run a real coding agent as a workflow step, not a chat completion:

• Codex Node – Runs the OpenAI Codex CLI in an isolated Heym workspace against a GitHub repository. Supports Sign in with ChatGPT (PKCE OAuth on your Plus/Pro subscription, no per-token API cost) or an access token, clones the repo, lets Codex edit code, and returns summary, diff, changedFiles, and a draft pullRequestUrl.
• OpenCode Go Node – The same repository workflow through the provider-agnostic OpenCode gateway (Kimi, DeepSeek, Qwen, and more), executed in a hardened throwaway container: all capabilities dropped, read-only root, pid/memory/CPU limits. The GitHub token never enters the sandbox—Heym performs every git and GitHub operation host-side, so generated code cannot exfiltrate push credentials.

That means a workflow can triage a bug from a webhook, hand the repo to a coding agent, wait for the draft PR, and post the link to Slack—fully automated, with resource limits configurable per deployment.

n8n's OpenAI node covers chat and assistant API calls, and native Codex support is still a community request. Zapier documents the reverse integration—Codex calling Zapier tools over MCP—rather than a coding-agent Zap step. Make.com's OpenAI modules expose completions and batch actions only. As of July 2026, none of the three offers a first-party node that clones a repository, runs a coding agent, and opens a pull request.

Built-In RAG Pipeline

Heym includes a RAG / Vector Store Node and a managed Vectorstores tab. You can:

• Choose your vector backend: Qdrant (external server) or Postgres (pgvector) — vectors stored in Heym's own database with no extra service to run
• Insert documents into a vector store directly from a workflow node
• Perform semantic search and feed results into an LLM or Agent node
• Reference results with expressions like $ragNode.results.map("item.payload.content").join("\n\n")

n8n now offers vector store nodes, and Zapier has abstracted Knowledge Sources, but they require more assembly. In Heym, RAG is two nodes with full control over embeddings and retrieval.

AI Assistant: Build Workflows with Natural Language

The AI Assistant is a chat panel inside the workflow editor. Describe what you want—"create a workflow that takes user input, searches my knowledge base, and replies using GPT-4o"—and the assistant generates nodes and edges that are instantly applied to the canvas.

• Uses your own LLM credential (any supported model)
• Supports voice input for hands-free workflow design
• Auto-applies valid workflow JSON from the AI response to the canvas
• Streams responses in real time

Zapier Copilot and Make Maia now offer natural-language workflow generation, but they operate as separate steps before the canvas. Heym's assistant works directly inside the editor, streaming nodes onto the canvas in real time with voice support.

Workflow Analyzer: Run-Aware Feedback

The Workflow Analysis panel is a run-aware documentation and feedback tool built into the editor. Click Analyze, choose an LLM credential and model, and Heym generates an editable Markdown report for the current workflow.

Unlike a static note, the analyzer first runs the workflow when it can and includes the execution result in the prompt. The report covers improvement areas, the workflow's purpose, and a step-by-step explanation of what the nodes do. When a report already exists, Reanalyze streams a separate preview so you can accept the new version or keep the current shared document.

Adjacent competitor features stop at a narrower layer: n8n AI Workflow Builder can create, refine, and debug workflows from natural language; Zapier AI troubleshooting explains errored runs; Make.com Scenario History and AI agent reasoning steps help inspect execution details. Their public docs do not show the same shared, run-aware analysis document that lives with the workflow.

Open Production Runs on a Live Canvas

A production workflow does not become a black box just because it started outside the editor. Open any Running entry from either History dialog—or open the active run inside an Agentic Kanban card—and Heym attaches the normal workflow editor to that exact execution.

• Nodes that already finished appear with their results immediately
• The current node and pending downstream nodes keep pulsing as execution advances
• The Debug panel receives the same incremental node results as a canvas-started run
• The final output and execution highlights arrive without polling or starting a duplicate run
• Closing the editor only disconnects the observer; it never cancels the production workflow

The observer uses SSE backed by a cross-worker execution snapshot, so it works for webhook, schedule, chat, MCP, integration, and Board triggers even when another backend worker owns the run. The public docs for n8n executions, Zapier run statuses, and Make scenario history document adjacent status or history views, but not this same live attach-to-canvas experience.

Workflow-Powered Dashboards

The Dashboard tab is a user-built reporting surface where every chart widget is powered by its own hidden Heym workflow. A widget can call APIs, query BigQuery, search RAG/vector stores, run LLM steps, transform rows, and finish with a Chart Output node. You can create widgets manually, generate them with AI, fine-tune them later, cache results, and rearrange the grid visually.

The competitors' documented dashboard-like surfaces focus on operational visibility: n8n Insights tracks production executions, failures, runtime, and time saved; Zapier Zap History shows Zap runs and task usage; Make.com Scenario History shows run details, logs, exports, and full-text execution-log search. Those are useful monitoring tools, but they are not a workflow-native dashboard builder where each widget can be any automation graph you can model on the canvas.

Agentic Kanban Board

The Board tab is a built-in Kanban board where the columns themselves execute workflows. A card is not just a task—it is a persistent agentic job that carries context, conversation history, execution state, outputs, and workflow runs.

• Column workflow chains – Moving a card into a column triggers that column's workflow chain; an Agentic Kanban Model (your credential + model) maps card content into workflow inputs and turns outputs back into readable text
• Card attachments – Drop files onto a card; documents are extracted to text and images are passed to vision-capable models before each run
• Live run canvas – Open the active run inside a card and watch it execute on the real workflow canvas, node by node
• Team sharing – Share boards with users or teams with read/write permissions; chains on shared boards run with the owner's credentials, so collaborators never need their own
• Failure visibility – Failed cards surface an error-history indicator, and follow-up runs can pause to await comments

n8n, Zapier, and Make.com all integrate with third-party kanban apps (Kanban Tool, Wekan, NocoDB), but none of them ships a built-in board whose columns run its own automations. In Heym the board is a native surface of the platform: cards, workflows, credentials, and live runs all live in one place.

MCP (Model Context Protocol) Integration

Heym has native MCP support on both sides:

• As a client: Agent nodes connect to external MCP servers (Filesystem, Browserbase, custom tools) via stdio or SSE and consume their tools automatically
• As a server: Each workflow with an Agent node can expose its tools as an MCP server, reachable at /api/mcp/sse—letting Claude Desktop, Cursor, or other MCP clients call your Heym workflows directly

n8n, Zapier, and Make.com have all added MCP support. Heym differentiates by exposing every workflow as an MCP server endpoint out of the box, and by allowing agents to consume multiple MCP servers simultaneously with zero configuration.

Skills System

Skills are portable capability bundles—a SKILL.md instruction file plus optional Python scripts—that can be dropped onto any Agent node.

• The skill's instructions are prepended to the agent's system prompt
• Python files in the skill become callable tools
• Skills are reusable across workflows and shareable as .zip archives

This is analogous to giving your agent a job description and a toolbox in one drop.

Heym Drive: Built-In File Storage

The Drive tab is a file store built into the platform. Files generated by skills and workflows (PDF, DOCX, CSV, images) land there automatically, and board card attachments are stored there too.

• Share links – Public or password-protected (Basic Auth) download links with optional expiry and max-download limits
• Team sharing – Share files read-only with your teams, and remove all team shares in one action
• Bulk actions – Multi-select with shift-click ranges, bundle selections into a single ZIP download, or apply one share/password/delete setting to many files at once
• Agent access – Skills can opt in to read Drive files, so an agent can work over documents you or other workflows produced

Competitors treat file storage as someone else's job: n8n keeps execution binary data internally (optionally on S3) with no user-facing drive, Zapier's Files by Zapier holds files only for the duration of a Zap run, and Make.com passes files between apps with data stores limited to structured records. In Heym, generated artifacts have a permanent, shareable home inside the platform.

Browser Automation with Playwright

The Playwright node is first-party browser automation on the canvas—no external scraping service or community package required.

• Steps mode – Compose navigate, click, type, fill, screenshot, extract, and scroll actions visually
• AI steps with auto-heal – Describe an action in natural language and an LLM generates the Playwright actions; failed selectors can be healed automatically, and generated steps can be cached to skip future LLM calls
• Run Code mode – Switch the node to full Playwright Python for complex flows (disabled by default; runs in Heym's hardened sandbox when enabled)
• Authenticated sessions – Restore cookies/storageState before running, verify login with a selector check, and fall back to scripted login steps
• Network capture – Optionally collect JSON responses, headers, cookies, and browser storage alongside results

n8n has only community Playwright packages, with a native browser-automation node still an open feature request. Zapier Agents can browse and read pages, but Zapier documents no scripted browser-automation step. Make.com relies on HTTP modules and third-party scraping apps. Heym treats the browser as a normal node with the same expressions, credentials, and error handling as everything else.

Human-in-the-Loop (HITL)

Heym has a built-in Human-in-the-Loop system that lets agents pause execution, request human review, and resume from exactly where they left off.

• Agent checkpoints – Enable hitlEnabled on any Agent node to give it a request_human_review tool. The agent decides when a decision needs human oversight and calls the tool with a summary and draft.
• Public review URLs – Each review request generates a secure one-time link at /review/{token} (168-hour TTL). Reviewers can accept, edit & continue, or refuse—no login required.
• Execution snapshots – The workflow freezes its full state (conversation history, variables, tool results) so it resumes exactly where it paused after the reviewer responds.
• Notification branch – An optional review output handle lets you wire a notification flow (Slack, email, webhook) that fires when a review is requested.
• MCP tool approval policies – Written HITL guidelines are interpreted into approval scopes (always / once / never) so the agent can auto-approve low-risk tools and escalate high-risk ones.
• Multiple checkpoints – A single agent run can pause for review multiple times; each checkpoint is independent.

n8n supports AI tool-call approvals across chat, email, and collaboration channels, but it is centered on reviewing tool invocations rather than pausing with a full execution snapshot. Zapier's Human in the Loop handles approvals and data collection inside Zaps, while Make.com's Human in the Loop app adds structured review requests on Enterprise plans. Heym differentiates with public review URLs, edit-and-continue, notification branching, and snapshot-based resume from the same agent checkpoint.

See Human-in-the-Loop for the full reference.

LLM Guardrails

Heym has built-in Guardrails on both LLM and Agent nodes, so you can block unsafe content before a model response reaches downstream steps.

• Node-level safety toggle – Enable guardrails directly on the node that generates or processes user-facing content
• Broad policy coverage – Block violence, hate speech, sexual content, NSFW/profanity, harassment, illegal activity, personal-data requests, and prompt injection attempts
• Multilingual detection – Apply the same safety rules across Turkish, English, Arabic, Spanish, and other languages
• Workflow-native fallback – When a message is blocked, the node throws a typed workflow error that you can route through an Error Handler

n8n now ships a dedicated Guardrails node, and Zapier now ships AI Guardrails across its AI surfaces. Make.com documents agent rules and review flows, but its currently published first-party docs don't show a comparable standalone guardrails feature, so we mark it as limited. Heym's differentiator is that safety policy lives directly inside the LLM and Agent configuration and plugs straight into workflow branching and error handling.

LLM Traces

The Traces Tab provides full observability for every LLM call:

• Request and response payloads
• Per-call timing: llm_ms, tools_ms, mcp_list_ms
• Tool call names, arguments, and results
• Skills passed to the model

Make.com now offers a Reasoning Panel for agent steps. n8n shows intermediate steps but full tracing requires third-party tools like Langfuse. Zapier has no trace visibility. Heym's trace system is purpose-built for debugging agentic behavior with full request/response payloads and per-call timing.

LLM Token Cost Tracking

Every LLM call in Heym is automatically costed. The Traces Tab shows per-trace input and output token counts alongside a real-time USD cost derived from a synced pricing table.

• Per-trace cost – Input tokens, output tokens, and total USD shown on every trace row
• Cost analytics – KPI cards and a per-model cost chart update with the selected time range (1h / 24h / 7d / 30d / All)
• LLM Cost Table – A system table in the DataTable tab is seeded from Helicone every 24 hours; you can override prices or add custom rows for models not yet listed
• Missing-price warning – Traces for models without a pricing entry surface an inline warning with a direct link to the cost table

n8n has no native cost tracking and relies on community-built workaround workflows. Zapier bills AI steps as tasks only with no token-level visibility. Make.com's credits dashboard abstracts token usage into credits for Make-hosted AI and shows no breakdown at all when you supply your own API key. Heym is the only platform in this set with first-party, per-execution USD cost reporting out of the box.

Built-In Evals

The Evals Tab lets you define test suites and run them against any workflow:

• Create test cases with inputs and expected outputs
• Run the whole suite with one click
• Review pass/fail, actual vs expected, and run history
• Control temperature and reasoning effort per run

n8n added evaluations in v1.95.1 with dataset-based testing and custom metrics. Zapier and Make.com still have no eval support. Heym makes eval-driven development a first-class workflow with one-click test suites, pass/fail review, and per-run temperature/reasoning control.

Parallel DAG Execution

Heym's workflow executor uses a directed acyclic graph (DAG) scheduler. Independent nodes run in parallel automatically—no configuration needed.

• Nodes at the same dependency level are dispatched concurrently to a thread pool (max_workers=8)
• As soon as any node finishes, its downstream nodes are scheduled
• The Merge Node combines parallel branch results
• Multiple workflow runs execute concurrently; each run is fully isolated

Make.com and Zapier run steps sequentially. n8n executes sequentially by default and requires sub-workflow workarounds for parallelism. In Heym, parallelism is the default behavior determined by the graph structure.

See Parallel Execution.

Portal: Publish Workflows as Chat UIs

The Portal feature turns any workflow into a public-facing chat interface at /chat/{slug}:

• Optional authentication with per-user credentials
• Streaming execution (real-time node progress)
• File upload support
• Multi-turn conversation history

This enables teams to ship internal tools, customer-facing chatbots, and AI-powered forms without any frontend code—just a workflow and a URL.

Expression DSL

Heym's Expression DSL provides a clean, powerful syntax for referencing upstream node data:

• $input.text – Input node data
• $nodeName.field – Any upstream node's output field
• $global.variableName – Persistent global variables
• Array helpers: .first(), .map("field"), .join("\n")

Expressions work in every string field—prompts, HTTP headers, conditions, set values—making dynamic data flow natural. Make.com now has a capable function library, and n8n uses JavaScript-based expressions. Zapier's in-line formulas remain more limited. Heym's DSL strikes a balance between power and readability without requiring full JavaScript knowledge.

Self-Hosted, You Own Your Data

Like n8n, Heym is self-hostable. Unlike Zapier and Make.com, your automation data, credentials, and LLM calls never touch a third-party SaaS platform. For AI workloads that process sensitive documents, customer data, or proprietary knowledge bases, this is a hard requirement.

Heym is licensed under the MIT License with the Commons Clause condition. The source code is source-available—you can use, modify, and self-host it freely. The Commons Clause restricts selling the software, including offering paid hosting or consulting/support services whose value derives substantially from Heym. For commercial licensing, enterprise deployments, or professional support, contact enterprise@heym.run.

Related

• Introduction – Platform overview
• Quick Start – Build your first workflow
• Workflow Analysis – Generate shared run-aware workflow reports and improvement feedback
• Dashboard Tab – Build workflow-backed dashboards with AI-generated chart widgets
• Agent Node – LLM node with tool calling, MCP, and skills
• Agent Architecture – Sub-agents, orchestrator, and tool dispatch
• Board Tab – Agentic Kanban board with workflow-executing columns
• Codex Node – Run the OpenAI Codex coding agent against a GitHub repo
• OpenCode Go Node – Provider-agnostic coding agent in a hardened container
• Drive Tab – Built-in file storage with share links, teams, and bulk actions
• Playwright Node – First-party browser automation with AI steps and code mode
• RAG / Vector Store Node – Vector search and document insertion (Qdrant or Postgres pgvector)
• AI Assistant – Natural language workflow builder
• Human-in-the-Loop – Agent checkpoints with public review URLs
• Guardrails – Block unsafe prompts before they reach your models
• Traces Tab – LLM call observability
• Evals Tab – Test suites for AI workflows
• Portal – Publish workflows as public chat UIs
• Parallel Execution – DAG-based concurrent execution
• MCP Tab – MCP server and client configuration