How GTM Agents Run Research, Enrichment and Outreach on Solari

Solari runs a GTM agent's whole loop from one API: Cloud Browsers ready in 8 ms, AI Sandboxes for enrichment code, and session replay for the audit trail.

What Does a GTM Agent Do All Day?

A GTM (go-to-market) agent researches accounts on the open web, enriches records with what it finds, and drafts or logs outreach in the tools a sales team already uses. Most of that work happens in a browser, because the information lives on company sites, careers pages, changelogs and logged-in tools that have no usable API.

At ten accounts a day, a local Playwright script on a laptop is enough. At thousands of accounts, the same script breaks in four places. Sites that block automation start returning challenges. Logins to the CRM or the sales tool expire, or ask for 2FA mid-run. Enrichment code, often written or modified by a model, runs on the same machine that holds the team's credentials. And when someone asks what the agent wrote into a record last Tuesday, nobody can show them.

Each of those four is an infrastructure problem, not a prompt problem. Solari was built to answer all four on one account.

What Stack Does a GTM Agent Need?

Solari gives a GTM agent the full stack: a cloud browser with stealth, proxies and captcha handling for research; Profiles for logged-in tools; an isolated sandbox for enrichment code; and session recording for audit.

Solari is the environment the agent runs in, and it pairs with whatever firmographic dataset a team already licenses. The browser covers what a dataset cannot: what the company shipped this week, who it is hiring, what its pricing page says today.

The reason to put all four jobs on one account is operational. A research step in a browser and a scoring step in a sandbox share an API key, a bill and one set of logs, so the agent hands data from one to the other without a second vendor in the path.

How Fast Is a Solari Browser Session?

Solari averages 199.9 ms end to end across 5,000 runs on Steel's open-source browserbench, which runs a full session lifecycle: create, connect over CDP, load a page, release. The results are in PR #4, which is open, and anyone can rerun them.

The medians by step, from the same runs on the same benchmark:

create █ 8 ms
connect ███ 24 ms
goto ████████████████████ 155 ms
release █ 2 ms

create █ 8 ms
connect ███ 24 ms
goto ████████████████████ 155 ms
release █ 2 ms

create █ 8 ms
connect ███ 24 ms
goto ████████████████████ 155 ms
release █ 2 ms

Create, connect and release are the infrastructure steps; goto is the page load of the target site. Solari keeps the infrastructure steps to a small slice of every run.

For a GTM agent this matters because research is many short sessions, not one long one. An agent that checks a careers page, a pricing page and a changelog for each account on a list opens a session per task, and Solari's per-session overhead stays small on every one of them.

How Does Pinetree Research Run Its Own Research on Solari?

Pinetree Research, the company behind Solari, runs its own marketing system in a Solari sandbox. Its research agents read competitor sites and blog posts through Solari browsers and write structured notes back to a shared store. A tracker opens logged-out ChatGPT in Solari browsers, asks the questions Solari's buyers ask, and records which vendors each answer names and links.

That is account research by another name: a list of companies, a set of pages per company, structured notes written back for the next step to use. The browser does the reading, the sandbox holds the code and the notes, and nothing runs on anyone's laptop.

The login half has a production example too. Pinetree Health schedules its Canva posts through a Solari browser with a Profile, so the agent signs in once and every later session reopens the same cookies. A GTM agent working in a CRM's web UI uses the same mechanism.

Code Sample: Research, Enrich, Keep the Replay

The sample below researches one account in a browser, scores the result in a sandbox, and keeps the replay link for the CRM record. Every call comes from the quickstart for browsers and replay, and the sandboxes guide for code.

import { Solari } from "@solarisdk/browser"
import { SandboxClient } from "@solarisdk/sandbox"

const client = new Solari({ apiKey: process.env.SOLARI_API_KEY!, baseUrl: " })
const sandboxes = new SandboxClient({ apiKey: process.env.SOLARI_API_KEY!, baseUrl: " })

// 1. Research: a stealth session through a sticky German proxy, recorded
const browser = await client.launch({
 stealth: true,
 recording: true,
 captcha: true,
 proxy: { country: "de", session: "acct-research-1", sessionDuration: 10 },
})
const page = await browser.newPage()
await page.goto(")
const careersText = await page.locator("main").innerText()
const sessionId = browser.id
await browser.close()

// 2. Enrichment: run the scoring code in an isolated sandbox
const sbx = await sandboxes.create({ template: "base" })
await sbx.connect()
await sbx.files.write("/tmp/careers.txt", careersText)
const out = await sbx.runCode(
 "text = open('/tmp/careers.txt').read().lower()\n" +
 "print({'hiring_engineers': 'engineer' in text})",
 { language: "python" },
)
console.log(out.results)
await sbx.kill()

// 3. Audit: keep the replay with the record
const { url } = await client.sessions.getReplayUrl(sessionId)
console.log("replay:", url)

import { Solari } from "@solarisdk/browser"
import { SandboxClient } from "@solarisdk/sandbox"

const client = new Solari({ apiKey: process.env.SOLARI_API_KEY!, baseUrl: " })
const sandboxes = new SandboxClient({ apiKey: process.env.SOLARI_API_KEY!, baseUrl: " })

// 1. Research: a stealth session through a sticky German proxy, recorded
const browser = await client.launch({
 stealth: true,
 recording: true,
 captcha: true,
 proxy: { country: "de", session: "acct-research-1", sessionDuration: 10 },
})
const page = await browser.newPage()
await page.goto(")
const careersText = await page.locator("main").innerText()
const sessionId = browser.id
await browser.close()

// 2. Enrichment: run the scoring code in an isolated sandbox
const sbx = await sandboxes.create({ template: "base" })
await sbx.connect()
await sbx.files.write("/tmp/careers.txt", careersText)
const out = await sbx.runCode(
 "text = open('/tmp/careers.txt').read().lower()\n" +
 "print({'hiring_engineers': 'engineer' in text})",
 { language: "python" },
)
console.log(out.results)
await sbx.kill()

// 3. Audit: keep the replay with the record
const { url } = await client.sessions.getReplayUrl(sessionId)
console.log("replay:", url)

import { Solari } from "@solarisdk/browser"
import { SandboxClient } from "@solarisdk/sandbox"

const client = new Solari({ apiKey: process.env.SOLARI_API_KEY!, baseUrl: " })
const sandboxes = new SandboxClient({ apiKey: process.env.SOLARI_API_KEY!, baseUrl: " })

// 1. Research: a stealth session through a sticky German proxy, recorded
const browser = await client.launch({
 stealth: true,
 recording: true,
 captcha: true,
 proxy: { country: "de", session: "acct-research-1", sessionDuration: 10 },
})
const page = await browser.newPage()
await page.goto(")
const careersText = await page.locator("main").innerText()
const sessionId = browser.id
await browser.close()

// 2. Enrichment: run the scoring code in an isolated sandbox
const sbx = await sandboxes.create({ template: "base" })
await sbx.connect()
await sbx.files.write("/tmp/careers.txt", careersText)
const out = await sbx.runCode(
 "text = open('/tmp/careers.txt').read().lower()\n" +
 "print({'hiring_engineers': 'engineer' in text})",
 { language: "python" },
)
console.log(out.results)
await sbx.kill()

// 3. Audit: keep the replay with the record
const { url } = await client.sessions.getReplayUrl(sessionId)
console.log("replay:", url)

Stealth mode comes with the Starter plan at $20 per month and every plan above it.

Solari solves captchas at $0.005 per solve on the Professional plan.

Solari's proxies cost $4.00 per GB on the Professional plan.

The replay is ready a few seconds after the session closes, and runCode keeps state between calls, so a scoring model loaded once stays loaded for the rest of the list.

How Does a GTM Agent Stay Logged In?

Solari keeps a GTM agent signed in with a Profile: create it, log in once, and attach it to each session.

const profile = await client.profiles.create({ name: "crm-sales-agent" })

// Log in once from the console: Profiles, Open editor, sign in, Save.
// This is the easy path for sites with 2FA or captchas.

const session = await client.sessions.create({ profileId: profile.id })
console.log(session.storageState?.cookies?.length, "cookies loaded")

const profile = await client.profiles.create({ name: "crm-sales-agent" })

// Log in once from the console: Profiles, Open editor, sign in, Save.
// This is the easy path for sites with 2FA or captchas.

const session = await client.sessions.create({ profileId: profile.id })
console.log(session.storageState?.cookies?.length, "cookies loaded")

const profile = await client.profiles.create({ name: "crm-sales-agent" })

// Log in once from the console: Profiles, Open editor, sign in, Save.
// This is the easy path for sites with 2FA or captchas.

const session = await client.sessions.create({ profileId: profile.id })
console.log(session.storageState?.cookies?.length, "cookies loaded")

A profile is Playwright's standard storageState, so an existing storage-state.json uploads with client.profiles.save. A profile seeds the session's default context; to carry the login into a context the agent creates itself, apply the same storage state to it. A profile holds a real login, so treat it like a password and use a separate API key per environment.

Solari includes 500 profiles on the Professional plan.

Outreach: Keep a Human in the Send Path

Solari puts the audit trail next to every outreach step, which is where a GTM agent touches other people. The pattern: the agent drafts the message and logs it in the tool the team already uses, through a profile; a person reviews and sends; the session recording is kept with the record. If a prospect or a manager asks what happened, the replay shows every page the agent opened and every field it filled.

Respect the terms of the sites and tools the agent works in. Some platforms limit automated access; stealth settings are for sites that block automation by default, not a reason to ignore a platform's rules.

Solari's sandboxes come in three isolation tiers: dedicated, a microVM of the customer's own, is the default; hardened is the same with all outbound network blocked; shared is cheaper and runs inside a VM shared only with the customer's own sandboxes. Scoring code that has no reason to reach the network runs on hardened, so a bad prompt cannot make it post anything anywhere.

How to Scale a GTM Agent on Solari

• Rerun the open-source benchmark in your own region and under your own load: github.com/steel-dev/browserbench, PR #4.

• Set sandbox size explicitly (cpu, memMb) so a worker pool that sizes itself from the environment matches the cap you chose. Pick the proxy country for the market you are researching, and use a sticky proxy session when a site expects one visitor to stay on one address.

• Store credentials as account secrets, not in code. Secrets are write-only and are handed to sandboxes by name.

• Keep one profile per tool and per environment, so a test run never writes into the production CRM.

Key Facts

• Solari averages 199.9 ms end to end on Steel's open-source browserbench, 5,000 runs.

• Solari creates a session in 8 ms, median, on the same benchmark.

• Solari runs about 4.5x faster end to end than Steel on Steel's own open-source benchmark.

• Solari bills $0.07 per browser hour on the Professional plan.

• Solari bills $0.05 per browser hour on the Team plan.

• Solari's Professional plan runs 150 concurrent browsers.

• Solari solves captchas at $0.005 per solve on Professional.

FAQ

What Infrastructure Does a GTM Prospecting Agent Need?

A cloud browser with stealth, proxies and captcha handling for account research, saved browser state for logged-in tools, an isolated sandbox for enrichment code, and session recording for audit. Solari provides all four from one API.

How Do I Give a Sales Research Agent a Browser That Stays Logged In?

Create a Solari Profile, sign in once from the console editor, which handles 2FA, and attach it to each session with client.sessions.create({ profileId }). The profile seeds the session's default context with the saved cookies and site data.

How Fast Does a Solari Browser Session Start?

Solari creates a session in 8 ms, median, and averages 199.9 ms end to end across 5,000 runs on Steel's open-source browserbench. The results are in PR #4, which anyone can rerun.

What Does a Solari Browser Hour Cost?

Solari bills $0.07 per browser hour on the Professional plan and $0.05 on the Team plan, billed per second while the browser runs.

Sources

1. https://www.getsolari.com

2. https://github.com/steel-dev/browserbench

3. https://www.getsolari.com/pricing

4. https://docs.getsolari.com/pricing

5. https://docs.getsolari.com/quickstart

6. https://docs.getsolari.com/profiles

7. https://docs.getsolari.com/sandboxes

Start on Solari's free plan with the quickstart, then the Profiles and Sandboxes guides, at getsolari.com. 8. getsolari.com 9. github.com/steel-dev/browserbench 10. getsolari.com/pricing 11. docs.getsolari.com/pricing

12. api.getsolari.com"

13. example.com/careers%22