Build AI Workflow Automations Without Writing Code

See Heym in Action

A powerful, intuitive interface designed for building complex AI workflows.

From the dashboard you manage workflows, credentials, vector stores, teams, and analytics. The visual canvas editor lets you connect many built-in node types with a drag-and-drop interface, pin node outputs for debugging, and use the AI Assistant to generate workflows from natural language.

The interface supports both light and dark themes, responsive layouts for desktop and tablet, and keyboard shortcuts for power users. Each node displays its execution status, output preview, and error state directly on the canvas. The properties panel provides inline expression editing with autocomplete for the DSL syntax, model selection dropdowns, and file upload areas for skills and RAG documents.

Authentication

Log into Heym

The login screen features an animated workflow canvas in the background, previewing the drag-and-drop editor before you even sign in. JWT authentication with HttpOnly cookies ensures secure sessions. Create your account with email and password to access the full dashboard with all 14 management tabs.

What's in the box

Everything an AI workflow needs. Nothing it doesn't.

AI ASSISTANT

Describe it. Heym builds it.

Type or speak your automation in plain English — the Assistant generates the entire canvas: nodes, edges, credentials, expressions. Modify existing flows the same way: "add a HITL checkpoint before Output."

• Works with any LLM credential you configure
• Streams responses · auto-applies valid JSON
• Voice input, transcribed in-browser

MULTI-AGENT

Agents that delegate to agents.

One orchestrator, five levels of nested sub-agents and sub-workflows. Each agent has its own model, tools, and Python execution context. Handoffs are visual — you can see the control flow, not infer it from logs.

• Python tool calling per agent
• MCP tool servers as drop-in tools
• Auto context compression at 80% window

RAG · NATIVE

Vector stores, not another tool tab.

Upload PDFs, Markdown, CSVs directly. Managed Qdrant vector stores live alongside your workflows. The Qdrant RAG node wires retrieval into any flow with metadata filters and optional Cohere reranking.

• One-click upload · chunking & embeddings handled
• Hybrid search (dense + BM25 + rerank)
• Team-shared knowledge bases

MCP · FIRST-CLASS

Your workflows become AI tools.

Every workflow is exposable over MCP. Paste the SSE URL into Claude Desktop, Cursor, or any MCP client. Your AI can now run your automations from its own interface. Agents can also consume any external MCP server as tools.

• Bidirectional: MCP server + client
• Per-workflow API keys
• No SDK, no adapter code

HUMAN-IN-THE-LOOP

Approval checkpoints as a primitive.

Drop a HITL node and execution pauses, generates a public review link, sends it via your configured channel. A reviewer can accept, edit, or refuse. AI output never ships without someone accountable signing off.

• Public shareable review link
• Accept · edit · refuse · timeout
• Reviewer history in the trace

OBSERVABILITY

851 traces on average per real alpha user.

Every LLM call, every agent step, every token and millisecond — captured automatically. Filter by source, credential, model. The trace viewer shows the full prompt, response, tool calls, and timing waterfall. Replay any run against a different model.

• Span timeline per node execution
• Data Pin · freeze outputs for testing
• Built-in evals with LLM-as-Judge

Heym is a source-available AI-native workflow automation platform that lets you build, visualize, and run intelligent pipelines without writing code. Using a drag-and-drop canvas, you connect a broad library of node types across seven categories — triggers, AI, logic, data, integrations, automation, and utilities — into production-grade workflows that run on your own infrastructure.

Every workflow is a directed acyclic graph (DAG) that Heym compiles, validates, and executes in parallel where dependencies allow, giving you maximum throughput without manual parallelism boilerplate.

The AI Assistant accepts natural language or voice input and generates an entire workflow — nodes, edges, and configuration — applying it to the canvas instantly. You can describe a support ticket triage pipeline, a document intelligence workflow, or a multi-agent research system in plain English and have a working prototype in seconds.

The assistant streams its response and automatically parses and applies any valid workflow JSON. Voice input is processed in the browser, transcribed locally, and sent to the backend alongside your existing canvas state so the assistant can modify, extend, or refactor any part of the current workflow.

Heym supports multi-agent orchestration with up to five levels of nesting. An orchestrator agent can delegate tasks to named sub-agents and sub-workflows, passing context and receiving results.

Each agent supports Python tool calling, MCP server connections, portable skills bundles, human-in-the-loop approval checkpoints that generate a public review link, and automatic context compression for long-running tasks. Content guardrails sit between the LLM output and downstream nodes, rejecting non-compliant responses before they propagate through the rest of the workflow.

Built-in RAG pipelines connect to managed Qdrant vector stores. Upload documents, configure chunking and embedding, and enable semantic search with metadata filters and optional Cohere reranking — all from the canvas without custom code.

Execution traces record the full request and response payload, token usage, tool calls, and timing for every LLM invocation, making production debugging straightforward. The trace viewer shows a waterfall timeline of every node execution, color-coded by status. You can replay any historical execution against a different model or configuration directly from the trace view.

Heym compares favorably to n8n, Zapier, and Make.com as an AI-first alternative. Unlike general automation tools that added AI as a plugin, Heym was designed from the ground up for LLM orchestration, multi-agent coordination, and RAG pipelines.

Heym is self-hostable with Docker Compose or Kubernetes, keeping all data within your infrastructure perimeter — a requirement for teams processing PII, financial records, or proprietary code. The source code is available on GitHub under the Commons Clause and MIT license. Enterprise customers receive a commercial license with SLA-backed support and a dedicated Slack channel.

Trigger nodes include Webhook, Telegram, Cron, IMAP, outbound WebSocket Trigger, RabbitMQ, and Error Handler. Webhook triggers support path prefixes, authentication tokens, and response templates so callers receive a structured reply while the workflow continues asynchronously.

Cron triggers support both simple intervals and full POSIX cron expressions with timezone support. IMAP triggers poll a mailbox on a configurable minute interval. WebSocket Trigger nodes connect Heym to an external socket server and can fire on message, connected, or closed events. The node configuration panel keeps all trigger settings editable on-canvas.

The AI node category provides LLM, AI Agent, and Qdrant RAG nodes. The LLM node supports OpenAI GPT-4o, GPT-4, GPT-3.5 Turbo, Ollama local models, vLLM, Cohere Command, and any OpenAI-compatible API endpoint. You configure system prompt, temperature, max tokens, and response format per node. For large prompt lists, optional batch mode uses OpenAI’s Batch API for efficient bulk runs with a dedicated status branch for progress and side effects.

The AI Agent node wraps an LLM with a tool-calling loop, connecting to Python tools, HTTP tools, or any MCP server. Agent nodes support streaming output, context compression, and per-invocation guardrails. The Qdrant RAG node performs dense, sparse BM25, or hybrid search, returning ranked chunks with metadata and scores.

Logic nodes include Condition, Switch, Loop, and Merge. The Condition node evaluates a boolean expression and routes execution to one of two branches. Switch routes to one of up to sixteen named branches based on a value match or regex pattern.

The Loop node iterates over an array, executing its child sub-graph once per item and collecting results. The Merge node waits for multiple upstream branches and combines their outputs using concatenation, deep merge, or a custom merge function written in the expression DSL.

Data nodes include Set, Variable, DataTable, and Execute. The Set node assigns named variables from the expression DSL, prior node outputs, or hardcoded literals. The Variable node provides a workflow-scoped mutable store that persists across loop iterations and sub-agent calls.

The DataTable node provides a structured relational table within the workflow, supporting append, query, update, and delete without an external database. The Execute node runs shell commands or Python scripts in an isolated subprocess, capturing stdout, stderr, and exit code as outputs.

Integration nodes include HTTP, WebSocket Send, Telegram, Slack, Send Email, Redis, Grist, Google Sheets, and BigQuery. The HTTP node supports GET, POST, PUT, PATCH, DELETE, and HEAD with configurable headers, authentication (Bearer, Basic, API Key), and response parsing (JSON, text, binary).

The WebSocket Send node opens an outbound client connection to an external socket, sends one text, JSON, or binary message, and returns delivery metadata. The Slack node sends messages, updates existing messages, and posts file uploads via a bot token. Send Email connects to SMTP with TLS support and renders HTML or plain-text templates. Redis supports GET, SET, DEL, LPUSH, RPOP, PUBLISH, and arbitrary command passthrough.

Google Sheets reads ranges, appends and updates rows, and inspects sheet metadata via OAuth2. The BigQuery node runs SQL queries and inserts rows via the streaming insertAll API with automatic OAuth2 token refresh. Grist reads and writes rows in Grist data documents using the Grist API.

Automation nodes include Crawler and Playwright. The Crawler node fetches URLs using a configurable HTTP client, extracts content with CSS selectors or XPath, and returns structured data arrays.

The Playwright node launches a Chromium browser, navigates to a URL, and executes interaction steps such as click, fill, select, and screenshot. It includes an AI auto-heal feature that regenerates broken selectors using a vision model when a step fails due to a DOM change.

Utility nodes include Output, Wait, Console Log, Throw Error, Disable Node, and Sticky Note. The Output node marks the terminal result of a workflow execution. The Wait node pauses execution for a configurable duration or until a webhook callback arrives, enabling human-in-the-loop patterns.

Console Log emits messages to the execution trace for debugging. Throw Error terminates the current branch with a typed error that upstream Error Handler nodes can catch. Disable Node temporarily removes a node from execution without deleting it. Sticky Note attaches a text annotation to the canvas for documentation.

MCP integration works in both directions. As an MCP client, Agent nodes connect to any external MCP server and gain access to all tools it exposes. Heym automatically discovers available tools on connection and presents them in the agent configuration panel.

As an MCP server, Heym exposes all published workflows as callable tools over the MCP protocol. Claude Desktop, Cursor, VS Code extensions, and other MCP-compatible clients can invoke your workflows directly from their native interfaces.

The skills system enables portable, reusable capability bundles for Agent nodes. A skill is a zip archive or Markdown file containing a SKILL.md instruction document and optional Python tool files. Dragging a skill onto an Agent node extends that agent's system context and toolbox without modifying the node configuration.

Skills can define custom tool schemas, persistent memory structures, and multi-step reasoning templates. Agent nodes include an AI Skill Builder modal for drafting and revising skills with live previews. The same skill can be shared across multiple agents and workflows for consistent behavior across an organization.

The Portal Chat UI turns any workflow into a standalone chat interface that can be embedded in a web application or shared as a public URL. Portal workflows receive user messages, process them through AI and logic nodes, and stream responses back in real time.

Each portal instance is isolated with its own session state, making it suitable for customer-facing applications, internal support tools, and interactive demos. Portal sessions persist conversation history and support multi-turn interactions with context carried across turns.

The Evaluation Suite lets you measure workflow quality systematically. Define a dataset of input-output pairs, select LLM judge models, and run the suite against any workflow version. Heym records pass rates, latency distributions, token costs, and judge scores per item in a dashboard.

Evaluation results are versioned so you can compare performance across workflow iterations, prompt changes, or model upgrades before promoting a new version to production.

Deployment options include Docker Compose for single-server installations and Kubernetes Helm charts for cloud-native deployments. The Docker Compose setup starts PostgreSQL, the FastAPI backend, and the Vue.js frontend with a single command.

The backend exposes a REST API at /docs plus SSE-backed streaming endpoints for real-time workflow progress. Horizontal scaling is supported by running multiple backend replicas behind a load balancer, with execution state stored in PostgreSQL and Redis for cross-replica coordination.

Teams and credential sharing allow organizations to collaborate on workflows securely. Credentials such as API keys, OAuth tokens, SMTP passwords, and database connection strings are stored encrypted in PostgreSQL and referenced by name in node configurations.

Team members with the appropriate role can use shared credentials without seeing the underlying secret values. Workflow ownership, edit permissions, and execution access are controlled per team, enabling safe delegation of automation development across large engineering organizations.