System statusby Solari Status ↗

How to Build a Research Agent That Reads the Live Web

·

6 min read

·

Summarize with AI
ON THIS PAGE

Updated November 10, 2026

In 2026, research is a job you hand to an agent. Since OpenAI launched deep research in ChatGPT, agents that search, read and cite the web have become a standard product, and engineering teams now build their own for pricing checks, market scans and due diligence.

Every one of those agents is only as good as the pages it reads. To build a research agent that reads the live web, you pair a search API that finds the pages with a cloud browser that renders each one, then add a saved login for paid sources, a sandbox for the analysis and a recording of every read. This guide covers the five steps, what each one needs to run reliably, what it costs and where research agents go next.

Why Does a Research Agent Need a Real Browser?

A research agent needs a real browser because most pages worth reading do not exist until a browser builds them. A model's training stops at its knowledge cutoff, so anything current has to come from a page your agent loads today.

The old way was a plain HTTP fetch. It works on static pages and comes back empty on a single-page application, where JavaScript fills in the content after the first load. Pricing pages, dashboards and most modern docs are built this way.

The new way gives your agent a headless browser that renders each page the way a person sees it. That fixes the empty pages and brings two new problems: the best sources sit behind logins, and running hundreds of Chromium instances yourself turns research time into browser upkeep.

A real browser also makes your agent's answers checkable. Every claim in the final report traces back to a page the agent loaded, at the moment it loaded it, instead of to text a model remembered from training.

How Do You Build a Research Agent, Step by Step?

You build it in five steps, each handing its output to the next:

  • Find the pages. Discovery runs on the search API your model already calls, and any provider that returns ranked URLs works. The output is a list of URLs, and that list is where the browser takes over.

  • Read each page in a real browser. Open one browser per page, let it render, pull the text and close the session. Run the reads in parallel and a long list of sources takes minutes instead of hours.

  • Keep logins for paid sources. Paid databases and subscription sites are often the sources most worth reading. Save a login once and every later session opens already signed in, so your agent never stalls on a sign-in form.

  • Analyze the pages in a sandbox. The model writes code to compare, count and chart what it read. Run that code on an isolated machine, never on your own servers, so a bad line of generated code cannot reach anything that matters.

  • Record every source. Record each read so a person can replay exactly what the agent saw. When an answer looks wrong, you check the page instead of guessing.

The read step is the core of the build. This function opens one Solari browser per URL, all in parallel, and closes each one once the text is in hand:

import { Solari } from "@solarisdk/browser"

const client = new Solari({ apiKey: process.env.SOLARI_API_KEY! })

async function read(url: string) {
  const browser = await client.launch({ recording: true })
  try {
    const page = await browser.newPage()
    await page.goto(url)
    return { url, text: await page.locator("body").innerText() }
  } finally {
    await browser.close()
  }
}

const pages = await Promise.all(urls.map(read))
import { Solari } from "@solarisdk/browser"

const client = new Solari({ apiKey: process.env.SOLARI_API_KEY! })

async function read(url: string) {
  const browser = await client.launch({ recording: true })
  try {
    const page = await browser.newPage()
    await page.goto(url)
    return { url, text: await page.locator("body").innerText() }
  } finally {
    await browser.close()
  }
}

const pages = await Promise.all(urls.map(read))
import { Solari } from "@solarisdk/browser"

const client = new Solari({ apiKey: process.env.SOLARI_API_KEY! })

async function read(url: string) {
  const browser = await client.launch({ recording: true })
  try {
    const page = await browser.newPage()
    await page.goto(url)
    return { url, text: await page.locator("body").innerText() }
  } finally {
    await browser.close()
  }
}

const pages = await Promise.all(urls.map(read))

Every session option is opt-in, so this is Solari's fast default browser with recording switched on. Add stealth: true only for the sources that block bots. Stealth sessions count against their own, lower cap and Solari answers an over-cap session with a 429, so queue those reads instead of firing them all at once.

What Role Does Solari Play?

Solari is the infrastructure a research agent runs on: cloud browsers, sandboxes and desktops from one API. Your agent brings the questions and the model; Solari gives it a place to read and work at the scale research needs.

  • Every source in one pass. Solari browsers are ready in 8 ms, and with Solari you can launch up to 100,000 browser sessions at once. Your agent reads every URL the search step returns in one pass instead of working down the list one page at a time.

  • Paid sources that stay signed in. A Solari profile saves your login, cookies and site data, so every session your agent opens starts already signed in. Profiles use the same storage state format as Playwright, so a login you already have imports as is. A profile seeds the session's default context only, so read through browser.newPage().

  • Sources that block automation. Turn on stealth for the sites with bot defenses, route traffic through a proxy in the country you choose and let Solari solve any CAPTCHA that appears. Every other source runs on the default browser, which starts faster and costs less.

  • Code that cannot touch your systems. A Solari sandbox gives your agent an isolated Linux machine whose runCode call runs Python and keeps variables and imports between calls, so the agent loads the pages once and queries them step by step. For code the model wrote a moment ago, pick the hardened isolation tier: a microVM of your own with all outbound network blocked.

  • A record of every read. Record a session and replay it later in the console, or download it as a line-by-line log of everything that happened on the page. Recording captures input values by default, so leave it off for any session that types a password.

  • Bring the agent you have. Solari sessions work with Playwright, Puppeteer and any client that speaks the Chrome DevTools Protocol. You move an existing research agent over by connecting it to the session's endpoint instead of a local browser.

Some sources only open inside an app. Solari desktops give your agent a full Linux computer with a screen for those, on the same account and the same bill as your browsers and sandboxes. Introducing Solari shows how the three fit together.

What Does It Cost to Run a Research Agent?

Cost comes down to the browser hour, because reading pages is where a research agent spends its time. Solari's rate per browser hour falls as your usage grows:

Solari browser hour price as usage grows

A paid plan's monthly fee counts toward that usage rather than adding to it. Stealth, proxies and captcha solving need a paid plan: stealth sessions bill at a higher rate than the default browser, proxy traffic bills per GB and captcha solving bills per solve, so turn them on only for the sources that need them.

Per browser hour, Solari is about 2x cheaper than Browserbase, so an agent that reads thousands of pages a day costs you less to run on Solari.

Where Are Research Agents Going Next?

Today most research agents answer one question and stop. Over the next year that changes in four ways:

  • From answers to standing watches. Agents will rerun the same research on a schedule and report only what changed: a new price, a new hire, a rewritten policy. The question becomes a monitor.

  • Teams of agents. A reader, an analyst and a fact-checker will work the same question and check each other, so a weak source gets caught before a person reads the report.

  • Paid and private sources by default. Research agents will read the subscription databases and internal tools a team already pays for, which makes saved logins as basic as search.

  • Agents that use any app. Models with computer use already operate software through a screen, clicking and typing like a person. Research agents will pull from tools that never shipped an API.

What stays human is judgment: which question is worth asking, which sources deserve trust and what the answer means for the decision in front of you. The teams that win will spend their people on that and hand the reading to agents.

Get Started With Solari

Start with one question you answer by hand every week, such as a competitor's pricing, and point the read function at the first URLs your search step returns. Solari is the fastest and cheapest way to run cloud browsers and VMs for research agents. Get started with a free account and start running your agents today.

Share this article

Give every agent
a place to work

Browsers, sandboxes and desktops from one API. Start free and scale when you need to.

Planet horizon at sunrise
opsra logo

The Fastest AI Infrastructure

Unsubscribe anytime. See our Privacy Policy.

System status

Copyright © 2026 Solari

Engineered by Pinetree

opsra logo

The Fastest AI Infrastructure

Unsubscribe anytime. See our Privacy Policy.

System status

Copyright © 2026 Solari

Engineered by Pinetree

opsra logo

The Fastest AI Infrastructure

Unsubscribe anytime. See our Privacy Policy.

System status

Copyright © 2026 Solari

Engineered by Pinetree