How to Build a Research Agent with the Neonlights AI Framework

Building a Self-Correcting Research Agent with Neonlights AI

Last quarter, I spent over 40 hours creating content briefs. That’s a full work week of copy-pasting SERP results, identifying keyword clusters, and trying to structure a coherent outline for a Writer. It’s tedious, soul-crushing work that’s necessary for good SEO but a terrible use of an operator’s time. I knew there had to be an automated solution that didn’t just spit out generic, hallucinatory garbage. This article shows you how to build the exact system I use now, based on a method I call the neonlights ai framework. You’ll learn to chain together specialized AI agents to produce high-quality, factual research briefs automatically.

So, What Exactly is the Neonlights AI Framework?

First, this isn’t a new SaaS tool you have to buy. It’s a design pattern. An operator playbook. The core idea of the neonlights ai approach is to reject the single, massive “god prompt” that tries to do everything at once. Those are brittle and impossible to debug. Instead, you build a sequential chain of small, specialized AI agents. Think of it like an assembly line.

Each agent in the chain has exactly one job. One agent scrapes data. The next one cleans and summarizes it. A third agent finds patterns in the summaries. A final one builds a structured outline. The critical part is that the output of one agent becomes the validated, cleaned input for the next. This modularity is what makes the system resilient. When one part breaks, you know exactly which agent failed, and you can fix its specific prompt or logic without tearing down the entire system. It’s how you move from AI toys to production automation.

The No-Code Stack for Your First Agent Chain

You don’t need to be a Python developer to build this. We’ll use off-the-shelf tools that connect visually. This is my current stack for this exact task.

• Orchestration: Make (formerly Integromat). This is the brain of the operation, connecting all the other services. Its visual, drag-and-drop interface is perfect for designing agent chains. I think its Pro plan, around $29/month, is fairly priced for the complexity it handles. Honestly, the free plan is a joke for anything beyond a two-step task, so expect to pay.
• Intelligence: OpenAI API (GPT-4o). This provides the reasoning for our agents. It’s not just about generating text; it’s about synthesis and structuring. API access is cheap for this kind of work; a few dollars a month will cover dozens of briefs.
• Data Extraction: ScrapingBee. To do real research, your agent needs to read the current top-ranking web pages. ScrapingBee is a service that handles the messy parts of web scraping, like dealing with blocks and rendering JavaScript.
• Memory: Airtable. This is where the outputs of each agent are stored. Using a structured database like Airtable instead of Google Sheets is a better practice. It forces you to be disciplined about your data format, which is essential for passing clean information between agents.

Building the 3-Agent Content Briefing Workflow

Let’s build the workflow. The goal is to provide a target keyword and get a complete content brief in Airtable a few minutes later. In Make.com, this will look like a linear sequence of modules.

Here’s the step-by-step process:

1. Setup the Trigger: Start with an Airtable module in Make.com set to “Watch Records.” This will trigger the automation whenever you add a new keyword to a specific base and table.
2. Agent 1: The Researcher. This agent’s job is to gather the raw material. It takes the keyword from Airtable, uses the ScrapingBee API to perform a Google search, and gets the URLs of the top 10 results. Then, it loops through each URL and uses ScrapingBee again to extract the clean text content from each page. The output—a big collection of raw, unstructured text—is saved to an Airtable field.
3. Agent 2: The Synthesizer. This is our first GPT-4o call. This agent takes the raw text dump from Agent 1 and distills it. Its sole purpose is to identify the core themes, recurring questions, and named entities (people, products, companies) mentioned across all the source articles. It doesn’t write anything new; it just finds patterns.

The prompt for this agent is crucial. It looks something like this:

The JSON output from this API call is then parsed and saved to new fields in your Airtable record.

4. Agent 3: The Structurer. This agent takes the structured JSON from the Synthesizer. It does not see the original raw text. This is a key detail. It prevents the agent from getting distracted and improves consistency. The Structurer’s job is to build a logical content outline. It suggests a title, writes a meta description, and arranges the themes and questions from Agent 2 into a hierarchy of H2 and H3 headings. This becomes the final content brief for a human writer.

This entire process, once built, is completely hands-off.

What Most Guides Get Wrong About AI Agent Frameworks

A lot of the tutorials and videos about building agents are, frankly, just glorified prompt engineering demos. They miss the operational realities of making these systems work reliably.

The biggest mistake is the obsession with a single, complex prompt. It feels powerful to write a 1,000-word prompt that tries to scrape, analyze, and write all at once, but it’s incredibly brittle. The moment the format of a source website changes or the API has a slight hiccup, the entire thing fails in unpredictable ways. The neonlights ai method of breaking the problem down into a chain of simple, single-purpose agents is more resilient.

Another common failure is not managing the state between steps. You must save the output of each agent. When your workflow fails (and it will), you need to see the data at each handoff point. Did Agent 1 fail to scrape the data correctly? Or did Agent 2 misunderstand the raw text? If you don’t log the intermediate steps, you’re flying blind.

This is my one-sentence paragraph.

How Do You Debug This When It Inevitably Breaks?

Your agent chain will fail. A website will block your scraper, the LLM will return malformed JSON, an API will time out. Plan for it. Debugging a multi-agent system requires a specific mindset: isolate the point of failure.

Because you’ve separated the concerns, it’s straightforward. Is the final outline bad? Don’t tweak the Structurer prompt first. Go look at its input. Is the JSON from the Synthesizer agent clean and accurate? If not, the problem is further up the chain. Go look at the raw text fed into the Synthesizer. Was it garbage? Then the problem is with the Researcher agent. This methodical, step-by-step diagnosis is only possible because of the modular design.

This is where a tool choice really matters. My concrete love is for Make.com’s execution history. You can visually inspect the exact bundle of data that passed into and out of every single module for any given run. You don’t have to guess what the API received; you can see it. This feature alone has saved me countless hours of frustration. Trying to debug this kind of system with custom code and `print()` statements is a special kind of hell.

My concrete gripe is with web scraping in general. Even with a great tool like ScrapingBee, some sites are just hostile to automation. My process can still fail maybe 5% of the time because a target site uses a particularly aggressive form of bot detection. I’ve learned to accept it and build in error-handling that notifies me so I can manually re-run the job for that specific keyword.

Is This Approach Actually Cost-Effective?

Let’s run the numbers for, say, 100 content briefs a month. A human researcher or VA, at a conservative $20/hour, might take 20-30 minutes per brief. That’s roughly 40 hours of work, or $800.

The automated system costs are:

• Make.com Pro Plan: $29/month
• ScrapingBee Freelance Plan: $49/month (covers enough credits)
• OpenAI API Costs: GPT-4o is very efficient. Each brief runs through two agents, processing maybe 30,000 tokens total. At current pricing, 100 briefs would cost around $5.

The total monthly cost for the automation is about $83. It pays for itself after you generate about 5 briefs. The initial setup might take an afternoon, but the operational cost is trivial compared to the manual labor it replaces.

You can certainly build this yourself following the steps I’ve outlined. The process of tuning the prompts and mapping the data fields correctly is where you’ll spend most of your time.

We cover this in more depth elsewhere — deeper coverage of AI agent platforms.

If you’d rather skip the build and deploy a working version in an afternoon, we’ve packaged this entire workflow as a production-ready blueprint at deepusecase.com/vault.