Building Your First AI Agent with Relevance AI (Without Writing Code)

What Is Relevance AI, Really?

You need to automate a process that requires a bit of thinking—like summarizing articles, categorizing leads, or drafting personalized emails. You’ve tried stringing together Zaps, but the logic gets messy fast. Writing Python scripts using OpenAI’s API is an option, but you don’t want to manage servers and dependencies. This is the exact gap Relevance AI is built to fill.

Think of it as a visual canvas for building AI-powered workflows, which they call agents. You drag and drop blocks representing tools (like a web scraper), language models (like GPT-4), and logic (like if/then conditions). You connect these blocks to pass data between them. It’s a proper AI agent framework designed for operators, not just developers. Honestly, for this kind of multi-step AI logic, it’s a much better fit than trying to chain a bunch of Zaps together. You get more control over the prompts and the data flow without the overhead of a full-blown coding environment.

The Anatomy of a Simple Research Agent

Before we build, let’s map out the components. Every useful agent I’ve ever built follows a similar pattern. You don’t just throw one big prompt at a model and hope for the best. You break the problem into a chain of specialized tasks. It’s more reliable and easier to debug.

Our simple research agent will have five distinct parts:

• 1. Trigger: This is the starting point. It’s the data you provide to kick off the workflow. In our case, it will be a simple form where we input a topic and a URL to analyze.
• 2. Tool 1 (Scrape): The agent needs information. The first real step is to use a tool to fetch the raw content from the provided URL. This is often the first point of failure.
• 3. LLM Step (Summarize): We’ll feed the raw, scraped text to a language model. The prompt for this step will be highly specific: summarize the content from the perspective of a business analyst.
• 4. LLM Step (Categorize): We then take that clean summary—not the messy original text—and feed it to a second, different LLM step. Its only job is to classify the summary into one of a few predefined categories. One tool, one job.
• 5. Output: The final result. The agent presents the summary and the assigned category.

This multi-step approach is the core of building automations that don’t constantly break. Each node in the chain has one responsibility, making it predictable and fixable when something goes wrong.

What Most No-Code AI Guides Get Wrong

Most tutorials you’ll find show a perfect, one-shot demo. They paste in a URL, click run, and a beautiful summary appears. This is a lie. Production systems are never that clean. They ignore the three things that will absolutely wreck your automation: messy data, bad prompts, and tool failures.

They don’t tell you that half the websites out there will break a simple web scraper, feeding your agent a useless lump of JavaScript and menu links. They don’t explain that your prompt’s performance will degrade if the input text is full of garbage. They suggest your agent will just magically “understand” what to do.

They treat prompts like magic spells.

A real operator playbook focuses on defense. You have to assume the scraper will fail. You have to assume the LLM will hallucinate or return data in the wrong format. A good workflow isn’t just about the happy path; it’s about anticipating the unhappy paths and building in checks and balances.

Building the Research Agent: A Step-by-Step Example

Let’s build that competitor research agent. The goal: you provide your competitor’s homepage URL, and the agent returns a summary of their product and classifies them as B2B or B2C. Open up a new agent in Relevance AI and follow along.

1. Set Up Your Trigger (Inputs)
Every agent starts with inputs. In the visual editor, you’ll see a ‘Trigger’ node. Click it and define two inputs: a text field named topic_of_interest and another text field named url_to_research. This creates the form that starts the agent.

2. Add the Scraper Tool
Click the ‘+’ sign to add a new step. Search for the “Get Content from URL” tool. In its settings, you need to tell it which URL to fetch. You’ll use a variable from the trigger step. The field will look something like this: {{trigger.url_to_research}}. This dynamically pulls the URL you entered in the form.

3. Create the Summarization Prompt
Add another step, this time selecting the “LLM” node. This is where you talk to a model like GPT. We’re going to give it a very specific persona and task. Here’s the prompt:

You are a sharp business analyst. Your task is to read the text scraped from a company's website and provide a concise, one-paragraph summary. Focus only on three things: the core product being sold, the likely target customer, and any mention of a pricing model. Ignore marketing fluff. TEXT: {{steps.get_content_from_url.output.text}}

Notice we’re injecting the output from the scraper step directly into the prompt.

4. Create the Categorization Prompt
Add a second “LLM” node. This one will take the *output* of the summarizer, not the raw scraped text. This is key. A clean input yields a clean output.

Read the following business summary. Based on the text, categorize the company as one of the following: 'B2B SaaS', 'B2C Mobile App', 'Consulting Agency', or 'E-commerce Store'. Respond with ONLY the category name and nothing else. SUMMARY: {{steps.llm_1.output.text}}

Forcing the output format like this makes the result machine-readable, so you can use it in later steps (like updating a CRM field).

5. Define the Final Output
Finally, add an “Output” node. Create two output fields: summary and category. Map the output from the first LLM step to summary and the output from the second LLM step to category. Now when you run the agent, you get a clean, structured result.

How Do You Actually Debug This When It Breaks?

It will break. Here’s a playbook for fixing the most common failures I’ve run into.

Failure Mode 1: The Scraper Returns Nothing or Garbage
This is the most frequent problem. You run the agent, and it immediately errors out on the “Get Content from URL” step. This usually happens because the target site is a single-page application (built with React, Vue, etc.) that requires JavaScript to render content. The default scraper just grabs the initial HTML, which is often an empty shell.

• The Fix: Inside the scraper tool’s settings in Relevance AI, there’s usually an option to use a “Headless Browser.” This simulates a real browser, executing the JavaScript before it captures the text. It’s slower and costs more credits, but it’s necessary for about 50% of modern websites. If that still fails, you may need a dedicated scraping tool like Browse AI or Apify, which you can call via an API request step.

Failure Mode 2: The LLM Output is Inconsistent
Sometimes your summary is great. Other times it’s a rambling mess or the category comes back as a full sentence like, “The category for this company appears to be B2B SaaS.” This breaks any downstream automation that expects a clean value.

• The Fix: First, check the input. View the output of the scraper step. Is it clean text, or is it full of navigation links and ad disclaimers? If it’s messy, add a “Text Cleaner” or “Regex” step before the LLM to strip out the noise. Second, make your prompt even more explicit. Instead of just telling it the categories, give it an example (this is called few-shot prompting). For instance: `…Respond with ONLY the category name. For example: ‘B2B SaaS’.`

My biggest gripe with the platform is that the debugging tools can be opaque. When a complex step fails, the error message is sometimes a generic “Internal Server Error” (which, yes, is annoying). The only way to solve it is to work backwards. Test the last step with hardcoded data. Does it work? Yes? Then test the step before it. Isolate the part that’s actually broken.

Is Relevance AI’s Pricing Worth It?

This is always the real question. Relevance AI uses a credit-based system. The free plan gives you a small number of credits, which is enough to build and test a few agents like the one we just designed. It’s not enough for production traffic.

The Starter plan at around $29/month gives you a much larger credit pool. For our research agent, each run (scraper + two LLM calls) might consume 2-5 credits depending on the complexity. At that rate, you could run it hundreds or even thousands of times a month. For a solo operator automating lead enrichment or content processing, $29/mo is a fair price. It becomes a rounding error compared to the time saved.

What I really love is the “Deploy as API” button. Once your agent is working reliably, you click that button and Relevance AI gives you a secure API endpoint. You can call this workflow from a custom script, a webhook in your CRM, or even a Slack bot. This turns your visual workflow into a real, production-grade component in your business’s tech stack. That feature alone is what makes it a professional tool, not just a toy.

Adjacent reading: deeper coverage of AI agent platforms.

You can follow these steps to build your own research agent. It’ll take some trial and error, but it’s a solid way to learn the platform. If you’d rather skip the build and deploy a working version in an afternoon, we’ve packaged this entire workflow as an AI automation blueprint at deepusecase.com/vault.