How to Build an AI Agent (No Code)

TL;DR: Build an AI agent in Heym by adding a trigger node, connecting an Agent node with a system prompt, attaching tool nodes, and wiring an output. No code required. Enable persistentMemoryEnabled for a knowledge graph that persists across runs. The whole agent can be exposed as an MCP tool and called from Claude.ai in one click. Updated May 2026 with current adoption stats and the latest Heym agent node capabilities.

What is an AI agent? An AI agent is an autonomous software system that receives a goal, breaks it into steps, calls external tools to gather information or take actions, and produces a result without step-by-step human instruction. Unlike a simple chatbot, an AI agent decides which tools to use, in what order, based on the task at hand.

Key Takeaways:

• Heym's Agent node runs a full ReAct loop (reason, act, observe) on top of any supported model including Claude, GPT-4, Gemini, and reasoning models like o1 and o3
• Custom tools are Python functions defined directly in the canvas, with a JSON Schema for parameters and no server or deployment needed
• Turn any canvas node (Slack, Telegram, HTTP, Set, JSON Output Mapper) into an agent tool by connecting it to the agent's tools handle and marking agent-provided fields with the bot icon
• Build new nodes in-flow by hovering an existing edge and clicking the + button to insert a node between two others (InsertableEdge)
• Enable persistentMemoryEnabled to build a per-node knowledge graph that survives across runs and is injected as context on the next execution
• Connect any MCP-compatible server via stdio, SSE, or streamable HTTP transports from the MCP panel
• Mark one agent as orchestrator and list subAgentLabels to delegate tasks across a team of agents in parallel
• Add an HITL checkpoint and Heym pauses the agent at a public /review/{token} URL until a human approves, edits, or refuses

Table of Contents

• Why Build an AI Agent Without Code
• What You Need Before You Start
• Step 1: Choose a Trigger
• Step 2: Add and Configure the Agent Node
• Building on the Canvas: Insertable Edges and Context Menus
• Step 3: Give Your Agent Tools
• Step 4: Connect an Output Node
• Step 5: Test and Run Your Agent
• Structured Output, Reasoning Models, and Fallback Credentials
• Orchestrator Mode and Sub-Workflow Tools
• Human-in-the-Loop Reviews
• Guardrails and Context Compression
• Give Your Agent Persistent Memory
• Connect External Tools via MCP
• Three Real-World Agent Examples
• FAQ

Why Build an AI Agent Without Code

I am on the Heym team and use AI agents in production workflows daily. Everything in this tutorial reflects features available in Heym today.

This tutorial walks you through exactly how to build an AI agent without writing code, from choosing a trigger to deploying a multi-agent pipeline. It is written for developers, product teams, and technical operators who want to automate complex tasks with AI without writing and maintaining a full codebase. Building an AI agent from scratch in Python means managing dependencies, running an inference server, writing retry logic, implementing memory storage, and deploying the whole thing somewhere. That is a significant project, not a feature you add in an afternoon.

The business case for AI agents is growing quickly. The Stanford AI Index 2025 reported that AI agent research and production deployments grew faster than any other AI category in 2024, driven by the convergence of capable LLMs, tool-use APIs, and accessible orchestration frameworks (Stanford HAI, 2025). AWS reports that AI agents on Amazon Bedrock support multi-step tasks across enterprise APIs, with broad availability across industries from healthcare to financial services in 2025 (AWS Bedrock Agents documentation, 2025). Gartner predicts that by 2028, 15% of routine business decisions will be made autonomously by AI agents, a shift that is already visible in early-adopter teams today (Gartner, 2025).

No-code tools close the gap between wanting an AI agent and having one. Building an agent with a code framework means writing hundreds of lines before you can run a single test. In Heym, a working agent is a visual canvas with four types of nodes: a trigger, an agent, tools, and an output. You wire them together, write a system prompt in plain English, and hit Run. The entire reasoning loop, tool registry, and memory layer are handled by the platform, not by you.

If you are new to the broader concept, what is AI workflow automation is a good starting point before continuing. If you are still weighing whether you actually need an agent or a simpler chatbot for your task, our AI agent vs chatbot guide settles that question with a decision framework. Once your agent is running, AI agent use cases and AI agent memory are natural next reads.

What You Need Before You Start

Before you open Heym, gather three things:

1. A focused goal for the agent. The narrower, the better. "Summarize support tickets and post a daily digest to Slack" is a good agent goal. "Be helpful" is not.
2. An API credential. Heym supports Anthropic Claude, OpenAI GPT-4, and Google Gemini models. You need at least one API key added to your Heym credential store before the Agent node can run.
3. An output destination. The agent's result has to go somewhere: a Slack channel, an email inbox, a webhook endpoint, a database row, or another node on the canvas.

No local development environment, no Python, and no infrastructure setup required.

Step 1: Choose a Trigger

Every Heym workflow starts with a trigger node. The trigger determines when and how your agent runs. Heym supports six trigger types:

For your first agent, use Text Input. It gives you a test input field in the canvas that you can edit between runs without touching infrastructure. Once the agent produces correct outputs, swap the trigger to Cron or Webhook and everything else stays the same.

To add a trigger: open the node panel on the left, drag Text Input onto the canvas, and you have your starting node.

Step 2: Add and Configure the Agent Node

What is a ReAct agent loop? A ReAct loop (Reason + Act) is the execution pattern used by AI agents. The agent reasons about the current task, selects and calls a tool, observes the result, then reasons again, repeating until the task is complete or the iteration limit is reached. This loop allows an agent to gather external data and adapt its plan at runtime, rather than generating a single static response.

The Agent node is Heym's core AI reasoning unit. It runs a ReAct loop. Reason about the task, call a tool, observe the result, repeat until done, then return an output. You control the loop with three fields.

System Prompt

The system prompt is the agent's job description. Write it in plain English. A good system prompt answers three questions for the model:

• What is your role? ("You are a support ticket analyst.")
• What data will you receive? ("You receive raw ticket text from the Trigger node.")
• What should you output? ("Return a one-paragraph summary and a severity score from 1 to 5.")

You can inject values from upstream nodes into the system prompt using $expression references. For example: The user's name is $triggerNode.body.name.

Model

Select any supported model from the dropdown: claude-opus-4, claude-sonnet-4, gpt-4.1, gpt-4o, gemini-2.5-pro, gemini-2.5-flash, and more. Each credential you add to Heym unlocks the models for that provider. The context window size is displayed next to each model name, up to 1,047,576 tokens for gpt-4.1 and 200,000 tokens for the Claude and Gemini families.

Max Tool Iterations

Set maxToolIterations to limit how many tool calls the agent can make before it must return an answer. The default is 10. For simple single-step agents, set it to 3. For complex research agents that gather and synthesize multiple sources, 15 or 20 is appropriate.

Building on the Canvas: Insertable Edges and Context Menus

Once you have more than two or three nodes on the canvas, the way you add and rearrange nodes matters as much as which node you pick. Heym ships two features that speed this up considerably.

Insertable Edges (the + button on an edge)

Hover over any edge between two nodes. Heym shows a + button mid-edge. Click it and a node search opens, and the next node you pick is automatically wired between the two existing nodes. The original edge is replaced; no manual disconnecting and reconnecting required.

This is the fastest way to retrofit a logging step, a Set transform, a Switch branch, or a guardrail node into an existing flow. The same edge also exposes a trash icon when hovered, so you can delete a connection without selecting it first.

Node Context Menu (right-click)

Right-click any node on the canvas to open the context menu. The available actions are:

• Extract to Sub-Workflow: wraps the selected node (or group of nodes) as a new workflow and replaces the original selection with a single Sub-Workflow node. Useful for collapsing a complex local sub-graph into one callable step.
• Eval Agent: opens the eval runner for that agent node, so you can grade its output against a saved test set without leaving the canvas. This is the on-canvas entry to AI agent evaluation.
• Disable / Enable: temporarily skips a node during runs. The execution engine routes around disabled nodes and skips dependent calls.
• Duplicate: copies the node with the same configuration. Great for trying a different prompt or model on a parallel branch.
• Share as Template: converts the node (and its connections) into a reusable template that can be imported into other workflows.
• Delete: removes the node and its edges.

Insertable edges and the context menu turn the canvas from a static diagram into an editable surface, which is the single biggest reason building an agent in Heym is faster than writing the equivalent Python code from scratch.

Step 3: Give Your Agent Tools

Tools are what separate an AI agent from a plain LLM call. A tool is a capability the agent can invoke at runtime: fetch a URL, query a knowledge base, call an API, run a calculation. Without tools, the agent can only reason over what you give it in the prompt. With tools, it can interact with live data and external systems.

Key insight: IBM's 2025 Global AI Adoption Index found that 42% of enterprises have actively deployed AI in production applications, with tool-augmented agents representing the fastest-growing deployment pattern. Teams that previously needed custom integration code to connect LLMs to APIs now configure the connection in a no-code canvas in under 15 minutes (IBM Institute for Business Value, 2025).

Custom Python Tools

In the Agent node's Tools section, click Add Tool. Each tool has four fields:

• Name: a snake_case identifier the model uses to call it (get_weather, search_docs, parse_invoice)
• Description: plain-English explanation of what the tool does and when to use it
• Parameters: a JSON Schema object (OpenAI function-calling format) defining the inputs the tool accepts
• Code: a Python function body that receives the parameters and returns a result

Here is an example tool that counts characters in a string:

def count_characters(text: str) -> int:
    return len(text)

Set toolTimeoutSeconds (default 30) to bound how long any single tool call can run. The model decides when to call this tool based on the description you wrote. You do not need to tell it explicitly in the system prompt.

Canvas Node Tools (the bot icon)

You do not have to write code to give an agent more capabilities. Heym lets you connect a supported canvas node directly to an Agent node's tools handle. The agent then calls that node at runtime as if it were a tool.

This works well for integration nodes like Slack, Telegram, HTTP, Send Email, JSON Output Mapper, and Set. The flow is:

1. Drop the Slack (or Telegram, HTTP, etc.) node onto the canvas next to the Agent node.
2. Drag a connection from the Agent node's tools handle to the node.
3. On the connected node, fields show a bot icon. Click it to mark a field as agent-provided. Marked fields become required tool parameters the agent fills in at runtime. Unmarked fields stay fixed and are read from the node configuration as static values.

For example, connect a Slack node, keep the credential and channel fixed, then mark message with the bot icon. The agent now sees a Slack tool where it supplies only the message text. Credentials, channel, and workflow-specific options stay where you set them.

Tool nodes do not run as regular workflow steps; they run only when the agent calls them. Trigger nodes and control-flow nodes cannot be used as agent tools.

Sub-Workflow as a Tool

Add a workflow ID to the agent's subWorkflowIds field and Heym gives the agent a call_sub_workflow tool. The agent passes a workflow_id and a JSON inputs object matching the target workflow's input schema. Max depth: 5 nested sub-workflow calls. This lets you package complex multi-node pipelines as single callable tools the agent can plug into.

RAG Tool

Connect a RAG node to query your Qdrant vector store. Add a RAG node to the canvas, configure the vector store and query expression, then wire it to the Agent node. The agent calls the RAG node when it needs to retrieve relevant documents from your knowledge base. Qdrant is Heym's vector store. Other vector databases are not supported. Choosing between retrieval and training first? Our breakdown of RAG vs fine-tuning covers the decision in detail.

HTTP Tool

The HTTP node makes external API calls using a cURL-style command. Connect it to the Agent node and the agent can hit any REST API during its reasoning loop. For a detailed walkthrough of HTTP node configuration, see how to connect two APIs in an AI workflow.

Step 4: Connect an Output Node

Once the agent finishes its reasoning loop, it returns a result. That result needs a destination. Common patterns:

• Output node: displays the result in the debug panel, useful during testing
• Slack node: posts the agent's output to a channel (#alerts, #support-summary, etc.)
• Telegram node: sends a message to a bot or group chat
• Send Email node: delivers the result to an inbox with a configurable subject and body
• Set node: writes the output to a Heym Global Variable for use in downstream workflows

Connect the Agent node's output handle to the input of your chosen output node. If you want to post only the agent's answer text (not the full output object), use a $agentNode.output expression in the output node's message field to extract the relevant value.

Step 5: Test and Run Your Agent

With trigger, agent, tools, and output connected, run the workflow:

1. Click Run in the top bar (or send a message to the trigger if using Telegram, Slack, or Webhook).
2. The Debug Panel on the right shows each node's execution in real time: inputs, outputs, tool calls, and timing.
3. Inspect the Agent node's trace to see the full reasoning loop. Look at which tools the model called, what each tool returned, and how the model synthesized the final answer.
4. If the output is wrong, adjust the system prompt first. An underspecified prompt that leaves too much ambiguous for the model is the most common cause of incorrect agent behavior.

Iterate on the system prompt until the agent produces the right output on a representative set of inputs. Then change the trigger from Text Input to Cron or Webhook and the agent runs automatically from that point on.

Structured Output, Reasoning Models, and Fallback Credentials

Production agents usually need more than free-form text. Three Agent node features handle the most common production requirements.

JSON Output Mode

Toggle jsonOutputEnabled and provide a JSON Schema in jsonOutputSchema. Heym instructs the model to return data that matches the schema and exposes each field as a typed reference on the node output. A downstream node can then use $agentNode.status or $agentNode.reason without parsing the agent's text response.

Example: a moderation agent that returns { "status": "APPROPRIATE" | "INAPPROPRIATE", "reason": "..." }. The Switch node downstream routes on $agent.status directly. No regex, no JSON parsing helper, no glue code.

Reasoning Models (o1, o3, and Friends)

When you pick a reasoning model (o1, o3, or any provider equivalent) the Agent node UI swaps Temperature for Reasoning Effort (low, medium, or high). Higher reasoning effort lets the model think for longer before responding. This trades latency for more reliable multi-step reasoning, which is the right trade for research, planning, and code-review agents.

Fallback Credential and Model

Set fallbackCredentialId and fallbackModel on the Agent node. When the primary credential or model returns an error (rate limit, outage, blocked content), Heym automatically retries with the fallback before the run fails. This is the simplest way to keep an agent resilient across multiple LLM providers without writing your own retry layer.

Orchestrator Mode and Sub-Workflow Tools

Sometimes one agent is not enough. Two source-verified Heym features make multi-agent and multi-workflow patterns straightforward.

Orchestrator Mode

Toggle isOrchestrator: true on an Agent node and list the labels of other agent nodes in subAgentLabels. The orchestrator gets a call_sub_agent tool. When the orchestrator decides to delegate, it calls one or more sub-agents in a single turn, and they execute in parallel. The orchestrator then resumes once their outputs are available.

Each sub-agent must reference the orchestrator's prompt with $input.text in its User Message field so it receives the delegated task. Orchestrators cannot call agents that are not listed in subAgentLabels, which prevents accidental cross-talk.

Sub-Workflow Tools

The call_sub_workflow tool, enabled by adding workflow IDs to the agent's subWorkflowIds field, lets the agent invoke complete workflows as if they were tools. Heym enforces a 5-level depth limit to prevent runaway recursion. This is the right pattern when a particular task is already automated as its own workflow and you just want the agent to be able to trigger it.

Human-in-the-Loop Reviews

For high-stakes actions (sending external emails, posting public statements, writing to a production system), Heym ships a built-in Human-in-the-Loop (HITL) feature on the Agent node.

Toggle hitlEnabled and write a short hitlSummary describing when the agent should pause for review. When the agent encounters a matching situation, it calls the request_human_review tool. Heym pauses the run, generates a single-use public URL at /review/{token}, and exposes a separate review output handle on the node so you can wire the URL into Slack or email for notification.

The reviewer opens the URL and chooses:

• Accept the proposed action as written
• Edit & Continue with a modified Markdown body
• Refuse and let the agent continue with an empty result

The execution stays in a pending state until a reviewer responds. After resolution, Heym resumes from the stored execution snapshot and the agent continues with the approved context. The agent can request review multiple times in a single run if the task has multiple sensitive checkpoints. HITL is the safest way to put an agent in front of customers without giving it unsupervised write access.

Guardrails and Context Compression

Two more Heym features keep production agents safe and inside model context windows.

Guardrails

Enable Guardrails in the Agent node properties to block unsafe user messages (hate, violence, self-harm, sexual content) before the agent runs. The guardrail check runs against the trigger input, so it short-circuits the rest of the workflow rather than letting an unsafe message reach the model and tools.

Automatic Context Compression

Agents that iterate many times over large tool results (web scraping, document reads, long sub-workflow outputs) accumulate a lot of intermediate messages. When Heym estimates that the conversation has reached 80% of the model's context window, it automatically compresses the middle of the conversation: system prompt, first user message, and most recent user message are preserved verbatim, and everything in between is summarized into a single assistant message using the same model and credential. Compression events appear as Context compressed (N messages → summary) entries in the Debug Panel, the Execution history view, and the Traces tab, so the behavior is fully observable. Once your agent is live, our guide to AI agent observability covers the metrics and traces to watch in production. Compression is automatic for Agent nodes; you do not need to enable or configure anything.

Give Your Agent Persistent Memory

By default, each run of an AI agent starts fresh. The agent has no memory of previous conversations or tasks. For many workflows that is perfectly fine. For agents that handle ongoing relationships (customer service, personal assistants, research pipelines), memory is what makes the agent genuinely useful over time.

What is persistent agent memory? Persistent agent memory is a storage layer that records entities, facts, and relationships extracted from an AI agent's previous runs, then injects that accumulated knowledge as structured context into future runs. Unlike conversation history, which is discarded after each session, persistent memory grows with every execution, allowing an agent to build domain knowledge over hundreds of interactions without manual curation.

Enable persistentMemoryEnabled on the Agent node. When active, Heym runs a background extraction step after each run: a secondary LLM call reads the run's inputs, outputs, and tool results, identifies entities and relationships, and writes them to a knowledge graph stored in the database. On the next run, the graph is serialized as structured markdown and injected into the agent's system prompt as additional context.

A support agent with persistent memory recognizes returning users, remembers their previous issues, and avoids asking for information it already has. The memory accumulates across hundreds of runs without any configuration beyond flipping the toggle.

You can also share memory across agents. The memoryShares field lets you grant other agents read or read/write access to a given agent's knowledge graph, so a Summarizer agent can draw on the memory that a Research agent built over multiple runs.

For a deep dive into memory types and implementation patterns, see AI agent memory: types, patterns, and implementation.

Connect External Tools via MCP

The Model Context Protocol (MCP) lets your agent connect to any MCP-compatible tool server: web search, code execution, calendar access, file system operations, and community-built integrations.

What is the Model Context Protocol (MCP)? The Model Context Protocol (MCP) is an open standard developed by Anthropic that defines how AI agents discover and call external tools and data sources. An MCP server exposes a set of named tools with typed parameters; an MCP client discovers those tools at startup and calls them at runtime by name. MCP replaces per-integration custom adapters with a universal, agent-readable interface that works across any compatible AI system (MCP Specification, 2025).

In Heym, open the MCP panel from the left sidebar. Add an MCP connection with:

• Transport type: sse for hosted MCP servers, streamable_http for streaming endpoints, or stdio for local servers
• Server URL or command: the endpoint address or the shell command that starts the server
• Label: a friendly name that appears in the agent's tool list

Once connected, the MCP server's tools appear automatically in the Agent node's tool list. The agent calls them by name with parameters, exactly the same way it calls custom Python tools.

You can also expose your own Heym workflows as MCP tools. Toggle any workflow on in the MCP panel and it becomes callable by other agents, by Claude.ai via the Claude Connector, or by any MCP-compatible client. This turns a complex multi-node pipeline into a single reusable tool.

For more on building and connecting MCP servers, see how to build an MCP server and best MCP servers for AI workflow automation in 2026. For how nodes-as-agent-tools and multi-MCP clusters landed in Heym, the first-month changelog covers each feature in order.

Three Real-World Agent Examples

1. Daily Briefing Agent

Trigger: Cron (every weekday at 08:00 UTC)

Agent tools: HTTP node fetching a news API, HTTP node fetching a weather API

Output: Slack node posting to #morning-briefing

The agent fetches today's top headlines and the local weather forecast, synthesizes a two-paragraph briefing in the style defined in the system prompt, and posts it to Slack before the team starts work. Total canvas size: five nodes. Total setup time: under 20 minutes.

2. Support Ticket Classifier

Trigger: IMAP Trigger (new email to [email protected])

Agent tools: Custom Python tool that extracts email subject and sender metadata; RAG node querying a Qdrant knowledge base of previously resolved tickets

Output: Set node writing the classification result to a Global Variable, followed by an HTTP node POSTing the result to your ticketing system API

The agent reads the incoming email, checks similar resolved tickets in the knowledge base, assigns a category and severity score (1 to 5), and sends the structured result to your ticketing API. With persistentMemoryEnabled on, the agent improves its classifications as it processes more tickets over time.

3. Multi-Agent Research Pipeline

Trigger: Webhook (accepts a research topic as a JSON payload)

Orchestrator agent: Receives the topic and delegates to two sub-agents using isOrchestrator: true and subAgentLabels: ["Web Researcher", "Summarizer"]

Web Researcher agent: Uses an MCP web search server to gather sources and extract key facts

Summarizer agent: Reads the researcher's output and produces a structured report with citations

Output: Email node delivering the finished report to the requester

The orchestrator agent never does the research itself. It plans, delegates, collects sub-agent results, and routes the final output. This is a three-agent system running on a single canvas, coordinated entirely through Heym's multi-agent orchestration layer. For more on how these architectures work, see multi-agent AI systems: a practical guide.

For a sales automation example, an agent that scores inbound leads 1-10 against your ICP, alerts your sales team on Slack for hot leads, and triggers cold email outreach for the rest, see the AI lead qualification agent tutorial.

Limitations to keep in mind: AI agents are not fully deterministic. The same input can produce different tool call sequences across runs, particularly with temperature above 0. For business-critical workflows where auditability matters, review the agent's trace in the Debug Panel after each run, enable Guardrails to short-circuit unsafe inputs, and add an HITL checkpoint for actions that need human approval. Heym's automatic context compression also kicks in at 80% of the model's context window to keep long-running agents from overflowing.

FAQ

Do I need coding experience to build an AI agent in Heym?

No. Heym's visual canvas handles all the wiring. You write a system prompt in plain English, configure nodes through form fields, and optionally write small Python snippets for custom tools. You can also convert any compatible canvas node (Slack, Telegram, HTTP, Set, JSON Output Mapper) into an agent tool with one click using the bot icon, no Python required. No framework knowledge, no deployment, and no infrastructure management is required.

What is the difference between the LLM node and the Agent node?

The LLM node makes a single call to a language model and returns the response. It has no tool access and no reasoning loop. The Agent node runs a full ReAct loop: it can call tools, observe results, reason again, and repeat until the task is complete or maxToolIterations is reached. Use LLM nodes for simple text transformations and Agent nodes for tasks that require external data or multi-step reasoning.

What triggers can start an AI agent workflow in Heym?

Heym supports six trigger types: Text Input (manual, for testing), Cron (scheduled), Webhook/HTTP (triggered by an incoming POST request), Telegram Trigger, Slack Trigger, and IMAP Trigger (new email). You can change the trigger at any time without modifying the rest of the workflow.

How do I share memory between multiple agents?

Enable persistentMemoryEnabled on each agent that should have its own memory graph. Then use the memoryShares field to grant other agents read or read/write access to a given agent's knowledge graph. This lets a Summarizer agent read the memory built up by a Research agent over multiple runs without the two agents needing to communicate directly.

Can I expose my AI agent as an API or MCP tool?

Yes. Every Heym workflow has a webhook URL that acts as a REST endpoint. You can also toggle the workflow on in the MCP panel to expose it as an MCP tool, letting Claude.ai and other MCP-compatible clients call it directly via the Claude Connector using OAuth 2.1 authentication.

Building your first AI agent is the starting point, not the destination. As you get comfortable with triggers and tools, add persistent memory to make the agent smarter over time, connect MCP servers to extend its reach, and wire multiple agents together for tasks that need parallel reasoning. The patterns in this guide (trigger, agent, tools, output) scale from a five-node daily briefing to a twenty-node research pipeline without changing the fundamental approach. Start with one agent, one tool, and one clear goal. The rest follows from there.

Ready to go further? See what is agentic AI for the theory, LLM orchestration for patterns to chain and route multiple agent calls, best AI agent builders in 2026 for a broader landscape view. For an even faster start, try the text to workflow approach or the broader vibe coding loop applied to an agent. Describe your agent pipeline in plain English and let Heym's AI Canvas generate the canvas structure automatically. Or open Heym and build your first workflow today.