Flipping the Switch on My First AI Bot: Niche Discovery Agent

It only bloody works!

Once you get all the associated steps working smoothly, it turns out it’s not that difficult to actually stand up the AI agent, (at least it only took ~50 test runs).

Here you can see a sped-up version of Directory Prospector finding me new directory website niches!

Read on to see how I did it and what’s next.

Building an AI Directory Prospector

The Final Workflow

Here’s how the final workflow looks in Make.com. After much iteration it’s now running smoothly and producing consistent results. It still takes about 6 minutes to run. But that’s fine – this is the initiation of a new directory, it only needs to run once per idea/niche.

I’ll get more into the details of each step below.

Those of you who’ve been reading me a while will see that the new flow chart for this workflow is simplified compared to my first approach.

I managed to condense several steps into one, and my business API is working well to silo up secret sauce IP, (which makes it look a bit simpler than it is).

What’s great about standing this agent up first is that now I have lots of useful, built-in endpoints I can use for things like domain prospecting.

AI Directory Prospector: Step by Step

Here I’ll walk you through each step this AI Agent takes and give you more detail. Jump ahead if you’d prefer.

First up, let’s compare the two flow diagrams:

As you can see the steps match pretty cleanly. As fugly as Make.com is, I like that aspect of it’s UI.

Agent Step 1: Webhook

The first module is a simple webhook. This lets me ‘call’ the automation from outside of Make.

For now I’m literally making an API request via Postman API. Later I’m going to build a nice web-app for me to manage these automations.

Agent Step 2: AI Ideate & Research Agent

This step is an AI Agent, which is also a scenario (workflow). Make’s naming is confusing. That asside, it works quite well.

Here’s a screenshot of the complete setup for this agent. It’s just a prompt and a tool (which gives access to a Google Analysis API endpoint).

… this prompt has gained a bit of shouty fluff as it’s evolved. Don’t ask why I repeat myself in it, just know that it works! 😂

Agent Step 3: Router & Filter

After the AI Agent has done a bit of research it returns either a JSON dump of keywords and analysis, or {no_idea:true}.

In Make workflows, this is how you do forking.

You make a router, add a filter (in this case, “response does not contain ‘no_idea’”). You can then add a second route and set it as ‘fallback’ which is like a default catch all.

Here I’ve got it sending me a Slack message if it fails, but later that’ll get wired into a nice control panel.

Note: I used a Groq module to enforce JSON output after the router, because sometimes that’s just easier.

Agent Step 4: Domain Prospecting

If the workflow passes the filter test it moves on to Domain Prospecting.

Here it fires an initial call to my business API which uses a load of approaches to invent ~400 domain ideas:

• Exact match domain names
• Typed lists of prefixes/suffixes
• AI imagined
• AI wildcard mashups
• TLD’s: .com and .io

It’s slightly skewed to this project (e.g. prefixes/suffixes and tld’s), but I’ve done my best to make it generically expandable in the future.

As it goes it plugs these domain ideas into my domain prospecting system I wrote a while back.

This has the added benefit of me being able to see the domains in my old domain finding UI.

Agent Step 5: Check Domain Availability

This step is super simple. Having generated a bunch of potentially ripe domain names, next we need to check if they’re available.

For this we use a sub-scenario in Make; a Repeater and a HTTP call:

This is a particularly lazy approach, in that I’ve set the repeater to just run 20 times. Because the HTTP request is to my own business API, I do return the ‘count left’ value, but given that it costs me $0 to re-run it excess times, it’s quicker to simply overkill blast it.

Again, this HTTP request hits my own API which uses a Rapid API endpoint to see if each of the domains is available.

Agent Step 6: Go Mode

When the workflow hits step 6 we’re effectively done here. 😎

It does one last HTTP call to my API to get the ‘AI’s pick’ and full domain lists, then combines all the data into an output JSON.

For now this is pinging me in Slack, until I stand up Agent 2.

Prospector Agent: Appendix

Here I’d like to show you how simple automation making should be, and how in Make I’m fairly happy with it.

It took me 1 minute to set up this Slack ping:

In a few months we probably won’t even need to do this ourselves.

AI Directory Prospector Output

Here’s an example output for the input keyword ‘Online Booking Software’:

Idea: appointment booking software
-----------
Keywords:
- appointment booking software
- best appointment scheduling software for small business
- salon booking software
- appointment scheduling app
- appointment software

Audience Profile:
The typical audience for an appointment booking software directory website consists of small business owners and service providers looking to streamline their scheduling processes. They operate in sectors such as wellness, healthcare, beauty, and fitness, desiring user-friendly, efficient, and cost-effective solutions to manage appointments. This audience values flexibility, customer support, and features like calendar integration and automated reminders. Businesses range from small salons and medical practices to massage therapists and personal trainers keen on improving client engagement and reducing administrative workload.

Common Jargon:
{"SaaS":"Software as a Service","Multi-tenancy":"A software architecture in which a single instance of software runs on a server, serving multiple tenants.","API":"Application Programming Interface","UI/UX":"User Interface/User Experience","Cloud-Based":"Software that is hosted and accessed through the internet, as opposed to being installed locally on a system."}

Domains (AI Pick):
reserly.io
quickapt.io
appointme.io
appointhq.io
schedhub.io
timeslotr.com
schedswift.io
tinybooker.io
leanappt.com
appointsy.io

Domains (all available):
reserly.io
schedapp.io
schedhub.io
quickapt.io
bookeroo.io
... etc.

Tools I used to Automate my Agent

I’ve tested standing up various vital organs of this agent in n8n, Gumloop, Relevance AI, and Lindy (read that here).

All have had merits, but I didn’t test setting the full monster up in them to fairly compare how they’d do. What I did use is Make.

The Final Setup

• Make.com for ‘orchestration’
• My Business API for behind-the-scenes nuts and bolts work
• Rapid API calls for keyword research, and domain checks
• OpenAI API calls (o3/4o) for various fill-in tasks

In the end it wasn’t such a complex setup as I’d envisaged, and the output is pretty good!

What it Costs to Run AI Niche Discovery Agent

It’s cheap.

Compare this to employee hours of research and the cost of various tools for domain prospecting; it’s pretty cheap.

Like $0.48 per run, cheap.

Here’s the Make ops costs for the whole setup, including tests:

… that’s ~800 ops / 10k a month or $1.52.

… and that’s for probably 50 runs as I built and tested it. The last run used just 6 ops ($0.01).

This is the API endpoints the agent uses, unfortunately the latter reset itself somehow overnight, but in testing I found that on average it used about 2% and 0.20% of these endpoints allowance respectively.

… that’s $0.40 and $0.05.

I suspect that beefed up research and wider domain searching will push this up, but we’re talking under 50 cents to do a decent chunk of work.

Adding a few cents for the ~10 calls to OpenAI API’s takes this up to $0.48 per run.

AI Directory Prospector: FlowSpec

Here’s how the working AI Agent looks in FlowSpec. In this we see some limitations in the new workflow schema I’m tinkering with – really it needs support for tooling and perhaps better declarations for loops, (I’ll improve this soon, any input appreciated on the repo).

{
  "workflowTitle": "Directory Prospector (AI Directory Agent, part 1)",
  "workflowDescription": "This workflow takes a described niche, researches keyword opportunities, checks domain availability, and outputs a JSON project summary.",
  "globalTransitions": {
    "rerun": "default_rerun_logic",
    "human_needed": "default_human_review"
  },
  "steps": [
    {
      "stepTitle": "Start Input",
      "stepId": "start_input",
      "stepDescription": "Receive human input describing a niche (e.g. AI workflow tools).",
      "action": "captureNicheDescription",
      "parameters": {
        "inputType": "text"
      },
      "results": {
        "niche": "string"
      },
      "transitions": {
        "success": "ideate"
      }
    },
    {
      "stepTitle": "Ideate",
      "stepId": "ideate",
      "stepDescription": "Generate low-hanging-fruit keyword ideas using keyword data.",
      "action": "generateKeywords",
      "parameters": {
        "niche": "from start_input"
      },
      "results": {
        "ideas": "array of keyword ideas"
      },
      "transitions": {
        "success": "check_idea_viability",
        "fail": "no_viable_idea"
      }
    },
    {
      "stepTitle": "Search Engine Data API",
      "stepId": "search_api",
      "stepDescription": "Pull related terms and trend data using ProfitSwarm API.",
      "action": "fetchSearchTrends",
      "parameters": {
        "keywords": "from ideate"
      },
      "results": {
        "trendData": "object with trends and related terms"
      },
      "transitions": {
        "success": "check_idea_viability"
      }
    },
    {
      "stepTitle": "Idea Viability Check",
      "stepId": "check_idea_viability",
      "stepDescription": "Determine whether a legitimate idea exists based on keyword viability.",
      "action": "evaluateIdea",
      "parameters": {
        "ideas": "from ideate"
      },
      "results": {
        "viable": "boolean"
      },
      "transitions": {
        "success": "domain_prospecting",
        "fail": "no_viable_idea"
      }
    },
    {
      "stepTitle": "Domain Prospecting",
      "stepId": "domain_prospecting",
      "stepDescription": "Check 300+ domains to find the best available domain for the idea.",
      "action": "findDomains",
      "parameters": {
        "idea": "from check_idea_viability"
      },
      "results": {
        "domainChoices": "array of domains"
      },
      "transitions": {
        "success": "final_output"
      }
    },
    {
      "stepTitle": "Final Output",
      "stepId": "final_output",
      "stepDescription": "Return a complete JSON object with idea, keywords, audience, domains, and jargon.",
      "action": "outputProjectJSON",
      "parameters": {
        "idea": "from ideate",
        "keywords": "from search_api",
        "domains": "from domain_prospecting"
      },
      "results": {
        "projectJSON": "structured JSON object"
      },
      "transitions": {}
    },
    {
      "stepTitle": "No Viable Idea",
      "stepId": "no_viable_idea",
      "stepDescription": "Output an indication that no viable idea was found.",
      "action": "outputNoIdea",
      "parameters": {},
      "results": {
        "status": "no viable idea"
      },
      "transitions": {}
    }
  ]
}

What I Learned from Automating Niche Discovery

This is work I’ve done before. When I built nichereport I used a bunch of similar steps; it has been enjoyable to make it fully automated and refine the flows.

At some points of this challenge I’ve felt absolutely demolished with the progress; like at once I’m trying to do something which should be relatively achievable, but that can feel impossible.

All at once it just worked.

If you’re playing with automations, just keep cycling through it. Just keep nudging these workflows forwards. Sooner or later they ‘just work’.

I did notice a few things grinding my gears though:

• While Make has some version control, prompt changes aren’t tracked
• I find myself hopping all over the place testing, splicing prompts, etc.
• The urge to build a system to run these AI agents is intense
• I suspect I will, at least, build a no-nonsense human input layer

I am going to build a prompt store tool which’ll make mastering prompt engineering easy. It’s probably going to be a community-only release. You can get notified by joining the waitlist here.

Any human input tool I make will likely end up in the main github repo for you all to reuse, if useful 🙂

What I’m Automating Next

Now this first agent is standing up I’ll be moving on to the second agent. Let’s see what happens when we get a bit of swarm interplay started.

Thanks for reading, if you’re into automations, grab a copy of my AI Automations Blueprint, or give this a share – it means the world to me that you’re here.