Build an AI Research Agent That Works 24/7 Without Hallucinating

Most of the "AI research agents" people are proudly shipping right now are not research agents at all. They are a search box wearing a costume. Someone bolts a web search tool onto a language model, watches it return a tidy paragraph, and declares victory. Then a client asks where a number came from, the agent cannot say, and the whole thing quietly gets switched off. I want to argue the unpopular position: the model you pick is the least interesting part of a research agent, and the parts everyone treats as afterthoughts, the sourcing discipline and the loop control, are the entire product.

The model is not where the magic lives

Every thread about building a research agent starts with the wrong question, which is which model to use. People agonize over it as if the choice between one frontier model and another decides whether the thing works. It does not. A capable model with a lazy prompt and no source enforcement will confidently invent a company's revenue, a property's square footage, or a competitor's pricing, and it will do it in beautiful, fluent English that reads exactly like a real finding. The fluency is the trap. A worse model with strict instructions to only report facts it actually retrieved, and to attach the link behind every claim, will beat a better model running loose every single time on the one metric that matters, which is whether you can trust the output.

So the real design work is not model selection. It is building a system that physically cannot report something it did not gather. You do that with three plain parts. A brain, which is the model that reads the goal and decides the next move. A memory, which keeps the recent steps word for word and summarizes the older ones so the agent does not lose the thread halfway through. And tools, which are the hands: a search tool to find relevant links and a scrape tool to actually read a page. None of that is exotic. What makes it a research agent instead of a search wrapper is the instruction layer wrapped around it, and that is the part people skip because it is unglamorous.

Research loops, and one-shot scripts cannot

Here is the second thing the "just add search" crowd gets wrong. Real research is not linear, and a script that runs one search and stops is structurally incapable of doing it. Think about how you actually research anything. You open a few pages, you learn something, and that new fact sends you chasing three more angles you did not know existed when you started. A one-shot script has no mechanism for that. It fires one query, grabs one result, and writes an answer whether or not the answer is complete.

An agent earns its name precisely because it can loop. It plans, acts, looks at what it found, decides whether that is enough, and if it is not, it goes again with a sharper query informed by what it just learned. That looping is the whole point, and it is also where the second discipline comes in, because a loop with no limit is a different kind of failure. Left alone, an agent will happily spiral, opening page after page, running up cost and time, chasing a level of certainty no business decision actually requires. So the system prompt has to tell it to stop after a small number of iterations. The craft is in the tension between those two rules: keep digging when a genuine new question appears, but stop when you have enough to act. Get that balance wrong in either direction and you have either a shallow wrapper or a runaway.

Sources are a constraint you enforce, not a feature you hope for

The single most common mistake I see is treating "cite your sources" as a nice-to-have you mention once in the prompt and assume the agent will honor. It will not, at least not reliably, and this is the crux of my contrarian point. Anti-hallucination is not a model property you shop for. It is a constraint you build and re-build into the system, often repeating the same instruction in more than one place because the agent drifts away from it the moment the task gets long.

The rule that actually works is blunt: only write facts you gathered from a tool, and include the reference link behind every claim. When the agent is forced to attach a link to each sentence, two good things happen. First, you can check its work instead of trusting it, which turns the output from a black box into something a human can verify in seconds. Second, the requirement itself suppresses invention, because a fabricated claim has no link to attach, and a well-built agent notices the gap. There is a practical wrinkle here that trips people up. Web pages are often longer than the model can read in one pass, so before the agent reasons over a giant page, the content has to be summarized down with the research goal in mind, keeping the useful parts and dropping the noise. That summarize step is not a nicety either. Skip it and the agent silently truncates the page, reasons over half the story, and cites a source that does not actually support the claim.

Where I would actually deploy one, and where I would not

I am skeptical of the demos where a research agent is asked to write a full market report, because that is exactly the open-ended task where the loop control gets fuzzy and the sourcing gets sloppy. The place these agents genuinely earn their keep is narrow, repeatable research that feeds a decision, and lead qualification is the cleanest example I know.

Here is how I would set one up for a landscaping company I work with. The business gets a steady stream of email inquiries. Some are homeowners with a small yard, some are property managers with a dozen large commercial sites, and the crew has no fast way to tell which is which before they call back. So they waste callbacks on low-value jobs and let high-value ones cool. I would wire it so that when an inquiry email arrives, the system pulls out the sender's name and company and hands that to the research agent. The agent searches for the company, scrapes the relevant pages, and reports back what kind of property or portfolio they manage, roughly how large it is, and any public signal of budget, with a link behind every single line. That scored summary drops into a simple sheet. Now, before anyone picks up the phone, the owner can see that one inquiry is a single small yard and another is a property manager with twelve commercial sites worth calling first.

Put illustrative numbers on it. If qualifying one lead by hand means twenty minutes of opening tabs and reading, and the crew gets thirty inquiries a week, that is ten hours gone before a single quote is written. An agent that does the same pass in about a minute, around the clock, gives those ten hours back and, more importantly, makes sure the twelve-site property manager gets a fast, informed callback instead of sitting behind three small-yard inquiries. The point is not that the agent is smart. It is that the task is narrow enough that the loop stays short and every claim carries a source you can check.

What actually makes it production-ready

Once the agent is reliable on its own, you wrap it as a web service so other systems can call it like any other tool, and that is when it stops being a toy in a chat window and starts being infrastructure. In the landscaping case, the trigger is an inbound email flowing through an automation platform, and the output lands in the sheet the owner already lives in. This is also where the work connects to the rest of a business. The scored leads do not sit in a vacuum. They feed the follow-up sequence in the CRM and website stack, so the twelve-site inquiry gets a fast human touch while the small-yard ones drop into a slower nurture. And the same qualification signal is gold upstream, because knowing which inquiries convert lets you sharpen who you target with Facebook and Instagram ad campaigns instead of paying to reach more small yards you will only turn away.

The trap of the impressive demo

I want to name the specific failure mode that keeps people stuck, because it is seductive. The impressive demo is the enemy of the reliable agent. Someone builds a research agent, asks it a hard question in front of a camera, and it returns a paragraph so fluent and confident that everyone claps. What the clip never shows is the second, third, and fourth run on slightly different inputs, where the same agent quietly invents a figure, cites a page that does not contain the claim, or loops until the cost is absurd. Reliability is boring and it does not demo well, which is exactly why so few of these systems survive contact with a real business.

The way you escape the trap is to invert how you judge the agent. Do not grade it on its best answer. Grade it on its worst answer across a batch of real inputs, because in production it will be handed the messy, ambiguous, half-empty inquiries, not the clean example you chose for the demo. For the landscaping agent, that means testing it on the inquiry with a vague company name, the one from a personal email with no website, the one from a property manager whose portfolio is spread across three different brands. Watch what it does when it cannot find much. A well-built agent says plainly that it found limited information and scores the lead as unknown, with links to what little it did gather. A brittle one fills the gap with a confident guess, and a confident guess is worse than no answer, because the owner acts on it.

This is also where the source rule proves its second value. When every claim must carry a link, a thin result looks thin, honestly, on the page. The owner sees two sources instead of eight and knows to treat that lead as unconfirmed. Strip the sources out and the same thin result reads exactly like a rich one, all fluent sentences, no way to tell the difference. That transparency is the entire reason the sourcing discipline matters more than the model. It does not just reduce hallucination. It makes the agent's confidence legible, so a human can calibrate how much to trust any single output. An agent that shows its work is one you can safely put in front of a business decision. An agent that hides it is a liability no matter how good the underlying model is.

My advice runs against the grain of the tutorials. Do not start by picking the fanciest model and dreaming up an open-ended research assistant. Start by choosing one narrow, repeatable research task, build brutally strict source enforcement and a hard loop limit around a modest model, and only then plug it into one real workflow. Test it on a handful of actual inquiries and tune the prompt until the summaries are genuinely useful and every claim survives a click. Get that right on one job before you expand to the next.

If you enjoy building, this is a rewarding project to take on yourself, and the discipline of forcing sources on every claim will make you better at every AI system you build afterward. If you would rather have a research agent wired into your real inbox and lead sheet, running around the clock with sources you can trust, that is the kind of system I set up for clients, and you are welcome to bring me in to build it.