BLOG
Fellou Browser: What It Is and How to Run One
Fellou Browser explained: an agentic browser for AI-driven tasks, how it compares to hosted Chromium, and how to run agent workflows in production.

Fellou Browser is an agentic browser: a desktop Chromium-based product built around the idea that the browser itself should execute tasks on your behalf, not just render pages. You describe an intent, and an embedded agent plans steps, navigates, fills forms, and reports back. That is a different product category from a hosted browser runtime, and the distinction matters if you are trying to decide where Fellou fits in a stack that also includes AI agents, Playwright scripts, and production automation. This guide explains what Fellou Browser does, where its model breaks down at scale, and how to run the same class of agent workflows on hosted Chromium with CDP access when you need reproducibility, isolation, and metered usage.
What Fellou Browser actually is
Fellou is positioned as an "agentic" or "action-oriented" browser. The core loop is: a user gives a natural-language task, an LLM-backed agent decomposes it, and the browser executes the resulting actions in a live session the user can watch. The pitch is that the browser becomes the operating surface for delegated work — research, form entry, cross-site data gathering — rather than a passive viewer.
Three properties define the product:
- Desktop-first. Fellou ships as an installable application for a personal machine. The agent runs alongside your local browser profile, cookies, and logged-in sessions.
- Human-in-the-loop by default. Because a person is sitting in front of it, the agent can pause, ask for confirmation, or hand control back mid-task. That is a genuine advantage for exploratory or high-stakes browsing.
- Consumer-shaped. The interaction model is a chat or command surface layered over a browser window, not an API. There is no documented CDP endpoint you connect a headless worker to.
None of that is a criticism. It is a coherent design for a single user doing ad hoc delegated browsing. The problems start when you try to move that model into a pipeline.
Where the agentic-browser model stops scaling
If you are evaluating Fellou Browser because you want agent-driven web tasks in a product or an internal automation system, four constraints show up quickly.
No programmatic session control. A desktop agentic browser assumes a human is present. Production agents need to create a session, drive it, and tear it down without a person in the loop. That requires an API and a protocol — typically the Chrome DevTools Protocol — not a GUI.
Local state is a liability. Running the agent on your machine means it inherits your cookies, your IP, and your logged-in accounts. That is convenient for personal use and unacceptable for multi-tenant workloads, where one task must not see another task's session.
No concurrency story. One desktop app runs one browser. If you need fifty parallel research jobs, you need fifty isolated browser instances somewhere else.
No reproducibility. Agent runs that depend on a local profile drift as that profile changes. Debugging a failed task means reconstructing a state you no longer have.
The practical conclusion: Fellou is a good fit for a person delegating browsing. It is not a runtime for agents that need to run unattended, in parallel, or under audit.
Hosted Chromium as the runtime for agent workflows
The alternative is to separate the agent from the browser. The agent — whether it is a browser-use loop, a Stagehand script, a Claude or Codex-driven planner, or your own orchestration code — connects to a remote Chromium instance over CDP. The browser runs on infrastructure you do not manage; the agent runs wherever your code runs.
Remote Browser is built around exactly this split. A session gives you:
- A real Chromium instance with a CDP WebSocket endpoint.
- Compatibility with Playwright, Puppeteer, and Selenium connection paths.
- A live viewer so a human can watch or intervene during a run.
- Persistent profiles so logins and cookies survive across sessions when you need them to.
- Session isolation so concurrent tasks do not share state.
- Configurable browser settings, including proxy configuration, for workloads that need specific network egress.
- Usage controls so you can meter and cap consumption.
The trade-off is explicit: you give up the "just talk to it" ergonomics of a desktop agentic browser and gain programmability, isolation, and scale. For a solo researcher, Fellou's model is better. For a team shipping an agent feature, the hosted model is the one that survives contact with production.
Fellou Browser vs. a hosted browser runtime
| Dimension | Fellou Browser | Hosted Chromium (Remote Browser) |
|---|---|---|
| Interaction model | Chat/command surface in a desktop app | API + CDP; you write the agent loop |
| Where it runs | Your machine | Provider infrastructure |
| Session isolation | Single local profile | Per-session isolation |
| Concurrency | One browser | Multiple sessions, subject to your plan |
| Programmatic control | Not the primary interface | CDP endpoint, Playwright/Puppeteer/Selenium |
| Human oversight | Built in, by design | Live viewer plus your own logging |
| Persistent logins | Local profile | Persistent profiles, opt-in |
| Best fit | Personal delegated browsing | Product features, pipelines, QA, research at scale |
Read the table as a fit question, not a ranking. The two products solve different problems.
Running an agent workflow on hosted Chromium
The mechanics are the same whether your agent is a hand-written Playwright script or an LLM that emits actions. You create a session, get a CDP endpoint, connect, and drive.
The snippet below uses Playwright's connectOverCDP, which attaches to an existing browser rather than launching one. The endpoint comes from your session-creation call; see the documentation for the current request shape and response fields.
import { chromium, type Browser, type Page } from "playwright";
interface SessionInfo {
cdpUrl: string;
sessionId: string;
}
async function createSession(): Promise<SessionInfo> {
// Replace with your provider's session-creation call.
// The response must include a CDP WebSocket URL.
const res = await fetch("https://api.example.com/v1/sessions", {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${process.env.BROWSER_API_KEY}`,
},
body: JSON.stringify({
// Persistent profile lets logins survive across runs.
profile: "research-agent",
// Proxy settings are configurable per session.
proxy: { country: "us" },
}),
});
if (!res.ok) throw new Error(`session create failed: ${res.status}`);
return (await res.json()) as SessionInfo;
}
async function runTask(task: string): Promise<string> {
const { cdpUrl, sessionId } = await createSession();
let browser: Browser | undefined;
try {
browser = await chromium.connectOverCDP(cdpUrl);
const context = browser.contexts()[0] ?? (await browser.newContext());
const page: Page = context.pages()[0] ?? (await context.newPage());
await page.goto("https://example.com/search", { waitUntil: "domcontentloaded" });
await page.getByRole("searchbox").fill(task);
await page.getByRole("button", { name: /search/i }).click();
await page.waitForLoadState("networkidle");
// Your agent's extraction or decision step goes here.
const results = await page.locator("[data-result]").allInnerTexts();
return results.join("\n");
} finally {
// Always close the connection; session teardown is separate.
await browser?.close();
}
}
runTask("quarterly earnings call transcripts").then(console.log).catch(console.error);Two details are worth calling out. First, connectOverCDP returns a browser whose contexts and pages already exist — you attach to them rather than creating fresh ones, which is what makes persistent profiles useful. Second, closing the Playwright connection does not necessarily end the remote session; teardown is a separate call so you can inspect a session after a failure. The Playwright CDP documentation covers the connection semantics, and the Chrome DevTools Protocol reference is the source of truth for the underlying domains.
Where the agent loop lives
With a hosted runtime, the agent is your code. That is more work than Fellou's turnkey chat surface, but it buys you control over the parts that matter in production:
- Model choice. Swap the planner without changing the browser layer.
- Retries and verification. Decide what "done" means and check it, rather than trusting a single pass.
- Logging. Record every action and page state so failures are reproducible.
- Cost control. Meter browser-hours and cap them per task or per tenant.
If you are starting from a browser-use-style loop, the remote browser for AI agents guide covers the runtime layer in more depth, and remote browser online walks through getting a session without local Chrome.
Production criteria to evaluate before you commit
Whichever path you take, judge it against the same checklist.
- Protocol access. Can you reach a CDP endpoint, or are you locked into a proprietary action API? CDP access means your existing Playwright and Puppeteer code works unchanged.
- Isolation guarantees. Are sessions truly separate, or do they share a profile? For multi-tenant work, this is non-negotiable.
- Profile persistence. Can you opt in to saved logins per workload without leaking them across workloads?
- Network control. Can you set proxies per session for geo-specific or egress-sensitive tasks?
- Observability. Is there a live viewer and a way to retrieve session state after a failure?
- Usage accounting. Is consumption metered in a way you can forecast? Check /pricing for current rates and limits rather than assuming.
- Failure semantics. What happens when a session dies mid-task — does your agent get a clear error, or a hang?
Fellou Browser answers questions 1–6 in a way optimized for a single human user. A hosted runtime answers them for a fleet of unattended agents. If your requirement is "my agent should browse the web reliably while I am not watching," the second column is the one you need.
When Fellou Browser is the right choice
Be honest about the fit. Fellou makes sense when:
- You are an individual doing exploratory research and want to delegate clicks.
- The task benefits from a human watching and correcting in real time.
- You want the agent to use your existing logged-in sessions on your own machine.
- You are evaluating what agentic browsing feels like before building it yourself.
It is the wrong choice when you need parallel sessions, per-tenant isolation, an API your backend can call, or an audit trail of every action. Those are runtime requirements, and a desktop app is not a runtime.
The practical path
The useful way to think about Fellou Browser is as a demonstration of the interaction model — delegate intent, watch the agent act — and hosted Chromium as the infrastructure that makes that model work when nobody is watching. You can prototype the interaction in a desktop agentic browser and ship it on a CDP-accessible runtime without rewriting your agent logic, because the agent logic was always the portable part.
If you want to see how session creation, CDP connection, and teardown fit together, start with the documentation. If you are comparing costs before you build, the pricing page has the current numbers. And if you are wiring an existing agent framework to a remote browser, remote control browser covers the control-plane details that trip people up first.