Log In Get Started Free

FREE COURSE • 3 video lessons • ~10 min

Build real AI automations, click by click.

Three hands-on lessons recorded in the live product. You’ll build a working AI API, an AI support agent that remembers customers and asks before it replies, and a multi-agent content pipeline with automatic error handling. No code required — follow along on the free plan.

Start building free Watch lesson 1

Lesson 1 · 3 min

APIs + AI Extraction

Build a live API that fetches any GitHub issue and uses AI to triage it into clean, structured JSON.

What you’ll learn

Webhook triggers, with separate test and production URLs
Calling a real API (GitHub) with the HTTP Request node
Passing data between steps with {{variables}}
Forcing structured AI output with a JSON schema
Testing, inspecting each node's output, and publishing

Docs used in this lesson

Webhook Trigger HTTP Request AI Prompt

Watch on YouTube →

Transcript

Intro

Welcome to the Falcon Builder AI automation course. In lesson one, you'll build a live API that reads any GitHub issue and triages it with AI.

What we'll build

Here's the plan. A webhook receives a repo and an issue number. An HTTP request fetches that issue from GitHub. Then an AI step reads it and returns clean, structured JSON: a summary, a category, a severity, the component, and a next step.

Create the agent

First, create an agent. An agent is a container for related workflows. We'll call ours AI Automation Course. Inside the agent, add a workflow, and start from a blank canvas. Give it a clear name, like Issue Triage API.

Webhook trigger

Every workflow starts with a trigger. Click Webhook Trigger in the node library, and it lands on the canvas. Name the node, and give the endpoint a readable path. Set it to respond when the workflow finishes, so whoever calls this API gets the AI result back. Falcon gives you two URLs: a test URL for drafts, and a production URL for the published version.

HTTP request

Next, add an HTTP Request node. Notice it connects to the trigger automatically. For the URL, use the GitHub issues API. The double curly braces pull the repo and issue number straight from the webhook body. Store the response in a variable called issue, so later steps can read it.

AI extraction

Now the AI step. Add an AI Prompt node, and switch the provider to Anthropic. Claude Haiku is fast and inexpensive for extraction work. The system prompt sets the role. The user prompt passes in the issue's title and body from the HTTP response. Here's the key move. Name the output triage, and add a JSON schema. That forces the model to return exactly these five fields, every time.

Test it

Let's test it. Open Test Workflow, and pass in a sample body: the React repo, issue #13991. Each node lights up as it runs. All three nodes passed. Click any node in the run panel to inspect exactly what it did.

Inspect the output

Open the full execution log to see the final output. There it is. Clean JSON: a summary, a category, a severity, the affected component, and a recommended next step. Any later step can use these fields directly, like triage.data.severity, to route urgent issues.

Publish

Finally, The production URL now serves this exact version. publish.

Recap

That's lesson one: a live API that calls a real service, and turns messy text into structured data you can build on. Next up, an AI support agent that remembers each customer, and waits for a human to approve every reply.

Lesson 2 · 3 min

Memory + Human Approval

Build an AI support agent that remembers every customer and never sends a reply without a human’s approval.

What you’ll learn

Conversation memory: one history per customer ID
Writing an AI persona and rules for support replies
Human-in-the-loop approvals, with approved and rejected branches
Reviewing drafts in the Approvals queue, with an audit log
Proving memory works with a follow-up message

Docs used in this lesson

Conversation Memory AI Prompt Webhook Trigger

Watch on YouTube →

Transcript

Intro

Welcome back. In lesson two, you'll build an AI support agent that remembers every customer, and never sends a reply without a human's approval.

What we'll build

A customer message arrives through a webhook. An AI step drafts a reply, loading that customer's conversation history. Then a human approval step pauses the run. Only an approved reply continues on to be sent.

New workflow

Open the course agent from the Agents page. Create a second workflow from a blank canvas, and name it Support Replies.

Webhook trigger

Start with a webhook. Your chat widget or help desk would post each customer message here. The body carries a customer ID, and the message text.

AI draft with memory

Add an AI Prompt node to draft the reply, and switch it to Claude. Give the agent a persona and a few rules, and pass in the customer's message. Now the important part. Name the output draft, and turn on conversation memory. The conversation ID decides whose history gets loaded. Use the customer ID, so each customer gets their own thread.

Human approval

Next, add a Human Approval node. It pauses the run until someone decides. The message shows the reviewer exactly what they're approving: the customer's text, and the AI's draft. The node has two outputs: approved,

Approved branch

and rejected. Add the step that runs once a reply is approved. Here we simply record the outgoing message. In production, you'd swap in Send Email, or WhatsApp. Slack,

Test: first message

Let's test it with a customer complaint about a cracked mug. The AI drafts a reply, and the run pauses, waiting in the approvals queue.

Approve it

Open the Approvals queue. The reviewer sees the customer's message and the AI draft side by side. It looks good. Add a comment, and approve it. The workflow resumes down the approved branch.

Test: memory

Now the memory test. The same customer sends a follow-up, without repeating any details. Look at the draft. It remembers order #1187 from the first message. That's conversation memory at work. And every decision is logged, with who approved it, and when.

Recap

That's lesson two: an AI that drafts replies, remembers each customer, and keeps a human in control of what gets sent. Next, we'll chain four AI agents into a content pipeline, and add error handling that catches failures automatically.

Lesson 3 · 4 min

Multi-Agent Pipeline + Error Handling

Chain four specialised AI agents into a content pipeline, then add a central error handler that catches failures automatically.

What you’ll learn

Grounding AI in a real source with an HTTP fetch
Multi-agent chaining, with outputs passed by variable
Structured SEO metadata with a JSON schema
Reading each agent's output in the run log
A central error workflow, wired to the whole agent

Docs used in this lesson

Failure notifications + error workflows AI Prompt HTTP Request

Watch on YouTube →

Transcript

Intro

Welcome to lesson three. You'll chain four specialised AI agents into a content pipeline, and add error handling that catches failures automatically.

What we'll build

A topic and a source URL come in. The source is fetched, then a researcher, an outliner, a writer, and an SEO packager each do one job, and hand off to the next. And if anything fails, a central error handler runs automatically, with the full details.

New workflow

Open the course agent, and create a third workflow called Content Pipeline.

Trigger + source

The webhook takes a topic and a source URL. Ground the pipeline in a real source. Fetch it first, and store it as source.

Four AI agents

Agent one, the researcher, pulls the key facts out of the source. Each agent gets its own role in the system prompt, and reads the previous step's output through a variable. Name each output so the next agent can use it: research, outline, and SEO. article, The outliner, writer and SEO packager follow the same pattern. Here it is, sped up. The last agent gets a JSON schema, so it returns a title, meta description, and tags. slug,

Test the pipeline

Test it with a topic, and a Wikipedia summary as the source. Four AI calls run in sequence. Once it finishes, open the run log to read what each agent produced.

Reading the outputs

The final output is the SEO packager's structured JSON. And each agent's result is saved under its own variable. Small, specialised steps are easier to debug and tune than one giant prompt.

Error handler

Now, what happens when a run fails? Build one central error handler for the whole agent. Create a workflow called Error Alerts, with a webhook trigger. Falcon calls it for you. Falcon passes the failure details in input.error. Capture the workflow name, the error message, and the execution ID. In production you'd post this to Slack or email. Save the workflow before leaving the editor.

Wire it up

Back on the agent page, set Error Alerts as the error workflow, and save. Then activate the agent, so its workflows and the error handler can run.

Break it on purpose

Now break it on purpose. Run the pipeline without a source URL. The run fails at Fetch Source: the URL was empty.

The handler fired

Open Executions. Right after the failure, Error Alerts ran automatically. It received the workflow name, the error message, and the ID of the failed run. Everything you need to alert your team.

Recap

That's the course: APIs and structured extraction, memory and human approvals, multi-agent pipelines and error handling. Everything you built is live in Falcon Builder. Now go automate something real.

Build it yourself

Everything in the course runs on the free plan. Create an agent, follow along, and you’ll have three working AI workflows by the end.

Start building free Read the docs