What is a research agent, and how is it different from ChatGPT with browsing?

The deliverable is a two-page brief in a folder: sources I can open, a list of what is still unknown, and a finish line. A thread about a vendor is not that file. Software that can search, retrieve, write the file, and stop is a research agent, and software that talks about the search is ChatGPT with browsing.

A research agent is software given a research job, a short list of search and file tools, and a finish line. It plans queries, reads what comes back, writes a memo with sources, and stops. ChatGPT with browsing still waits for your next message, because the product is the file, not the thread.

A research agent finishes a memo

A research agent is an AI agent whose job is research. You give it a question evidence can answer, tools that fetch that evidence, and a done condition a script can see. It runs until the memo exists or it hits a budget you set, and the product is the file.

I already wrote what an AI agent is as the parent definition. An AI agent is software given a job and tools, and expected to finish. A research agent is that loop pointed at evidence, and the output is a memo with claims, sources, and gaps, not more chat.

Anthropic’s Building effective agents (19 December 2024) draws the line I use: workflows are systems where LLMs and tools are orchestrated through predefined code paths, and agents are systems where the LLM dynamically directs its own processes and tool usage. Research tempts people to skip that line. Searching feels agentic, but a chat with a search box is still a chat.

The same essay says agents must gain ground truth from the environment at each step. For research, ground truth is a page, a file, a row, a 404. A fluent paragraph is not ground truth, and a citation the tools never returned is a miss.

• A goal you can test. “Look into this vendor” is not a goal. “Brief at /out/vendor.md, every claim tagged to a source, unknowns listed” is.
• Tools with names. Web search is not file search. Fetching a URL is not quoting a snippet as if you fetched it.
• A loop the runtime owns. Retries, memory, spend, and the stop rule do not live in the prompt.
• A budget. Steps, searches, tokens, time. Unbounded research is how a desk becomes an invoice.

ChatGPT with browsing is still a chat

ChatGPT with browsing is a conversation that can search the public web and reply in the same thread. You stay in the loop: you ask the next question and you decide whether the answer is enough. That is a strong assistant, not a research agent, until a runtime owns the loop and a file counts as done.

The split is not the model and it is not the existence of search. Both systems can call a search tool, quote a URL, and sound sure. The split is who owns the next step, and what finished looks like: in ChatGPT you own it, and in a research agent the runtime does, inside limits you wrote.

I use ChatGPT with browsing when I am still forming the question, and I will copy a paragraph into a note by hand. I do not pretend the thread is a deliverable. The moment the work has a buyer, a folder, and a due file, someone has to own stop, spend, and the source list, and in a chat that someone is me, clicking.

Browsing in a consumer chat also hides the contract: you rarely see the exact query, the result set, the skip, or the stop. A research agent that I will trust logs those: tool input, tool output, the claim that used it.

Anthropic’s December 2024 essay warned that agentic systems trade latency and cost for performance, and that many jobs only need a single call with retrieval. A chat with browsing is often that retrieve-then-generate product, not an agent.

The loop the runtime owns

A research loop is think, act, look, write, stop: the model proposes a query, a tool returns pages or passages, and the agent grades them. Thin evidence means another search. Enough evidence means write the memo and stop, and you read the file after instead of driving each hop.

Anthropic describes that loop without dressing it up: agents are typically LLMs using tools based on environmental feedback in a loop, and implementation is often straightforward. The hard part is the tools, the stop, and the score. I have watched teams spend a month on a research swarm, skip the finish line, and produce threads nobody could file as the answer.

1. 01

   Write the job so a script can see done

   Name the artifact, the claims it must cover, and the source rule. “Markdown in /out/brief.md, every factual sentence tagged to a source id, unresolved questions in a final section” is a job. “Research this market” is a vibe.

2. 02

   Let the model plan the next look, not the whole essay

   The first thought should be a query, a file search, or a fetch. If the model essays before it has looked, the prompt is asking for a blog post. Research starts empty, and the environment has to fill it.

3. 03

   Call a named tool and keep the raw result

   Web search, file search, URL fetch, a table read: log the call and keep the snippet and the identifier. Do not let the model rewrite the tool output into marketing language before the next thought.

4. 04

   Grade what came back

   Relevant or not, primary or secondary, dated or stale, resolves or 404. If the hit is a title that does not support the claim, it is not a source. This is the step ChatGPT with browsing hides in the reply.

5. 05

   Search again or write

   Thin evidence means another query, a narrower fetch, or a pass through the corpus. Enough evidence means write the memo. The runtime, not the model, caps how many times this can repeat.

6. 06

   Stop on the file, the budget, or a forbidden call

   Success is the artifact, and failure is a miss with a log. The model does not get a vote on spend. Unbounded “one more search” is how research agents fail in public.

That sequence is why I do not call a one-shot browse an agent. A one-shot browse is retrieve then generate, once, and LangGraph’s retrieval docs call that 2-step RAG: retrieval always happens before generation, high control, low flexibility, the FAQ shape. A research agent is the other column: the model decides when and how to retrieve during the job, latency becomes a variable, and you need a cap.

I keep write as a late step. If the agent drafts the memo on the first page it sees, every later source has to fight a paragraph that already exists, so the loop should collect, grade, then write. How to build a research agent is the construction note, and this piece stops at the definition because you cannot build the right loop if you still think the chat is the worker.

Search and files as hosted tools

The tools are not the agent. OpenAI Agents SDK exposes hosted tools that run on OpenAI’s servers next to the model, web search and file search among them, and you attach them to an agent you define. ChatGPT with browsing is the consumer product of a similar search capability: same family of action, different owner of the loop.

I verified the current SDK surfaces before writing this. In the Python Agents SDK, hosted tools include WebSearchTool, which lets an agent search the web, and FileSearchTool, which retrieves from OpenAI vector stores. In the JavaScript SDK the same pair is webSearchTool() and fileSearchTool(vectorStoreIds), and both pages describe these as hosted tools that execute with the model on OpenAI servers, not in your process.

OpenAI’s March 2025 post on new tools for building agents announced the Agents SDK alongside built-in web search, file search, and computer use on the Responses API. The current Agents SDK tools pages still treat web search and file search as the default hosted pair for a research-shaped worker. I do not need a dozen tools to start: I need those two, plus a way to write the file, plus a stop.

• WebSearchTool / webSearchTool: internet search. Optional location, filters, search context size on the Python class. Use it for current public pages, not for your private Drive.
• FileSearchTool / fileSearchTool: semantic search over vector store ids you pass in. max_num_results, filters, ranking options. Use it for the corpus you indexed. It will not fetch a URL you have not stored.
• A fetch or read tool if you need the full page after a hit. A snippet is not a source until you can point at the passage.
• A write tool that can only create the artifact path. Search is not save. Save is not send.

Web search is for the live public web, and file search is for the corpus I already trust enough to index. Mixing them in one worker is normal; mixing them without labels is how a blog post gets cited as if it were the 10-K. Anthropic’s December 2024 appendix on tool design says to invest in the agent-computer interface the way you would invest in a human-computer interface: obvious names, obvious parameters, tests for the mistakes the model actually makes.

File search is retrieval, not memory: a vector store returns the closest chunks to the query you sent, including the wrong clause with the right words. A worker that file-searches once and then answers is 2-step RAG, useful for FAQs and weak for a brief that has to survive a lawyer. The agent has to be allowed to query again, and to say the corpus does not contain the fact.

Workflows that already cover the path

Not every research job should be an agent. Anthropic’s December 2024 essay starts there: find the simplest system that works, and add a multi-step agent only when a simpler path falls short. Research has simpler paths vendors sell as agents, and I keep the names straight so I can choose.

Anthropic’s December 2024 essay already names the simpler graphs: prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer. I use a chain when the sources and sections are the same every week. I use evaluator-optimizer when the next search depends on whether the last page actually answered the question.

Those are still workflows if you drew the graph, and they become an agent when you cannot predict the number of steps and you let the model keep the baton, with a stop you wrote. I use a workflow when the product is the same every week: same sources, same sections, same checks. A weekly pricing brief from three known pages is a chain with gates; an agent on that job will wander into adjacent blogs and call it diligence.

I use an agent when I cannot draw the path: a new vendor, a messy public record, a question that might live in the corpus or on the web. The next query depends on the last passage. That is the open-ended case Anthropic reserved for agents, with the warning attached: higher cost, compounding errors, test in a sandbox, put guardrails on it.

Retrieval that chooses when to look

LangGraph’s retrieval docs draw the same split: 2-step RAG always retrieves, then generates, and agentic RAG lets the model decide when and how to retrieve during the job. Hybrid RAG adds grading and query rewrites. Their agentic example is a research assistant with multiple tools.

The LangGraph agentic RAG tutorial makes the decision explicit: a node calls the model with a retriever tool bound, and if the last message contains tool calls the graph retrieves, otherwise it answers. After retrieval, a grader can send the run to answer generation or back to rewrite the question. Retrieval is a tool node, not a fixed first step, and that is the difference between a docs bot and a research loop over a corpus.

YouTube

Open original

LangChain’s Self-reflective RAG with LangGraph (Self-RAG and CRAG), 7 Feb 2024, is the grade-then-retrieve loop this definition uses: retrieval is a tool node, not a fixed first step.

Operators inherit RAG slides. Someone indexes Confluence, wires retrieve-then-generate, and names it an agent, then it answers from nearest neighbors and skips stale checks, the public web, and the memo unless you built those pieces. 2-step RAG has high control, agentic RAG has variable latency, and you add complexity only when it demonstrably improves outcomes.

When I do want the graph, I steal three moves: decide whether to retrieve, grade the documents against the question, and rewrite the query if the hits are junk. The fourth move is mine: write the artifact as a node with a schema (claims, source ids, unresolved questions), not as a chat message. The graph is finished when the file writer succeeded and the stop edge fired; skip that and you built LangGraph ChatGPT, with serious traces and an empty folder.

The finish line I write first

Done is a file a script can see, with claims a person can check. I name the path, the sections, the source rule, and the unknowns section before I attach a tool. If only a person can tell that the research finished, a person will stay in the loop, which is where ChatGPT lives and a research agent cannot.

A finish line I will actually use is a markdown file at a known path: a one-paragraph claim at the top, numbered findings tagged to source ids, a source table with URL or file id and retrieved date, and a final section named Unresolved. If the agent cannot fill a required section, the run is a miss, not a creative essay.

• Artifact path and format. If it is not on disk, it did not happen.
• Coverage. The questions the job listed must appear as answered or as unresolved. Silence is a miss.
• Source rule. A claim without a source id is a miss. A source id that does not resolve is a miss.
• Contradiction rule. If two sources disagree, both stay, and the memo says so. The model does not pick a winner to look tidy.
• Budget. Searches, steps, time. Hitting the cap with no file is a miss.

I do not grade tone in the primary score. A stiff memo that maps claims to pages beats a warm essay that paraphrases a search snippet, and unresolved is part of done: the agent must be allowed to say it did not find the number.

I check whether the URLs resolve and whether the sentence is supported. I do not publish a fake citation accuracy rate.

How I score a research run

I score the artifact, not the chat. I freeze the job, keep more than one trace, log every tool call, and pass or fail the file against the finish line. Pretty traces that miss the sources are zeros, and Arena is that floor: frozen tasks, competing traces, the file as the score.

A research eval set is a pile of jobs I already know: last month’s vendor pack, a public filing with a number I can check, a question whose answer is not in the corpus, and a question whose answer is only in the corpus. Ten jobs is a start. I freeze them, because if I change the jobs every week the score is noise.

For each job I keep the tool log (query text, result ids, HTTP status, which claim used which id), and cost and step count are second scores. I compare against a baseline: last week’s agent, a 2-step RAG chain, or a careful human with an hour. If the agent does not beat the chain on the frozen set, I keep the chain, because the first users are people who will paste the memo into a deck, not a test set.

I do not invent a citation accuracy percentage for a blog. I have not run a public bake-off I can quote, and I will not dress a private desk score up as a market fact. The mechanism is binary on the claim: resolve the source, read the passage, and ask whether the sentence is supported, which is a test ChatGPT with browsing fails by construction, because there is no frozen job, no file, and no tool log you own.

Jobs that should stay a script or a chat

Write a script when a script with no model would fetch the three known pages and fill a template. Keep ChatGPT with browsing when the work is still a conversation. You do not have a research agent if you cannot say what done looks like. You have a longer chat.

The agent is for the messy middle: unknown path, checkable file, tools you can name. Stay on a script when the sources are stable and the extract is mechanical, such as prices from a known table or status from a known endpoint. Stay on a chat when you are still choosing the question, and stay on 2-step RAG when every question should hit the same corpus first and the answers are short.

Do not use a research agent as a stealth send. Research reads and writes an artifact, and outreach is a separate job with a separate score. Do not use a research agent when you cannot read the sources it would cite: if you cannot check the pages, you cannot score the file, so skip the agent and hire the person.

Anthropic’s customer-support and coding appendices in the December 2024 essay are useful even though they are not research. The pattern they liked had clear success criteria, feedback from the environment, and a place for a human. Research has that shape when the memo can be checked, and it does not when good research is a feeling in a thread, so feelings stay in chat.

Failure modes I treat as default

A research agent will still be wrong in regular ways: invented URLs, snippets that do not match the page, secondary blogs cited as primary filings, stale numbers with a confident tense, and corpus hits that share nouns and miss the clause. I treat those as the job.

When not to trust a research agent is the failure note. This section is only the list I design against.

Invented citations are a generation problem: the model knows what a URL looks like and can emit one that was never returned by WebSearchTool or FileSearchTool. The fix is mechanical. Every source id in the memo must appear in the tool log, or the claim is unsupported and the run fails that row.

Snippet laundering is next: search returns a title and a fragment, and the model writes a sentence the fragment does not support. Fetch or quote the passage, then write from it. If I cannot fetch, the memo says so, because a title is not a source.

Permission mistakes show up as research that suddenly acts, so the runtime should refuse anything but read and write-to-artifact. Compounding error is the cost of the loop: each bad hop becomes context for the next. If you cannot afford an evaluator pass, you cannot afford the agent, so use the chain or keep a human as the runtime.

Sources

This memo cites primary docs I opened while writing it. I am not quoting a vendor case study and I am not inventing a success rate. If a number is not in these pages I did not use it, and URLs sit in the list below so you can open the same files.

• Anthropic, Building effective agents, 19 December 2024. Workflows versus agents, when not to use agents, evaluator-optimizer and orchestrator-workers for search, ground truth from tool results, stop conditions, tool interface design. https://www.anthropic.com/engineering/building-effective-agents
• OpenAI, New tools for building agents, March 2025. Agents SDK, built-in web search and file search on the Responses API. https://openai.com/index/new-tools-for-building-agents/
• OpenAI Agents SDK (Python), Tools. Hosted WebSearchTool and FileSearchTool, vector store retrieval, hosted execution on OpenAI servers. https://openai.github.io/openai-agents-python/tools/
• OpenAI Agents SDK (JavaScript), Tools. Hosted webSearchTool and fileSearchTool helpers. https://openai.github.io/openai-agents-js/guides/tools
• LangGraph, Build a custom RAG agent with LangGraph. Retrieve as a tool node, grade documents, rewrite the question, decide whether to retrieve. https://docs.langchain.com/oss/python/langgraph/agentic-rag
• LangChain, Retrieval. 2-step RAG versus agentic RAG versus hybrid, with research assistants as the agentic example. https://docs.langchain.com/oss/python/deepagents/retrieval

The parent definition is what is an AI agent, the construction note is how to build a research agent, and the failure note is when not to trust a research agent. This page is only the split: a research agent is a job-complete loop that writes a memo with sources, and ChatGPT with browsing is a chat that can search. Use the chat while you are still in the question, and use the agent when the file has a path.