← Blog

BLOG

Fellou AI Browser: When to Use It vs a Browser API

Evaluate Fellou AI browser for assisted browsing and learn when a hosted Chromium API is a better fit for production web automation.

10 min readRemote Browser
Ivory computer towers connected across terracotta platforms in a quiet desert landscape
The infrastructure behind your browserREMOTE BROWSER / ILLUSTRATION

Fellou AI browser is an AI-oriented browser for people who want assistance with web tasks. It is a different kind of product from a hosted browser API: Fellou centers the user’s browsing experience, while an API such as Remote Browser gives developers Chromium sessions that application code or agents can control.

Choose Fellou when the main requirement is an AI-assisted browser experience for an individual. Consider a hosted browser runtime when you need to initiate sessions from code, integrate them with a service, isolate workloads, or inspect automation centrally. The two approaches are not necessarily direct substitutes.

This guide focuses on that decision, including what to test before adopting either approach and how to build a small hosted-browser proof of concept.

What does Fellou AI browser do?

Fellou is positioned as an AI browser: a browser experience designed around using AI to help with activities on the web. The practical appeal is that a person can work in a browser while delegating parts of a task to an assistant, rather than manually navigating every page and collecting every result.

The distinction is who initiates and supervises the work. For an individual evaluating Fellou AI browser, useful questions include:

  • Can it help gather and synthesize information from the pages needed for the task?
  • Can the user inspect the sources or browser state behind an answer?
  • What happens when a task requires signing in or interacting with sensitive information?
  • Can the user review an action before it changes data or submits a form?
  • How does the browser behave when a site changes, blocks an action, or asks for verification?

Test these questions against your actual workflow. Product capabilities, platform support, availability, and commercial terms can change; check Fellou’s current documentation and product information before making a deployment decision.

An AI browser can be useful without being the right foundation for a backend service. A developer building an automation product also needs to consider how browser sessions are created, controlled, observed, and stopped outside a person’s desktop.

Fellou AI browser vs a hosted browser runtime

A hosted browser runtime runs browser sessions on remote infrastructure and exposes a way for supported automation clients to control them. Remote Browser provides hosted Chromium sessions with Chrome DevTools Protocol (CDP) access, compatibility with Playwright, Puppeteer, and Selenium, and operational features such as a live viewer and persistent profiles.

Decision pointFellou AI browserHosted browser runtime
Primary starting pointA person using an AI-oriented browserCode or an agent controlling a remote browser session
Best fitAssisted browsing and individual web workflowsApplication integration, scheduled jobs, and managed automation
Browser controlEvaluate the controls exposed by the current productUse supported automation tooling and a provided connection endpoint
Session locationVerify the current product’s execution and data-handling detailsChromium runs as a hosted session
AuthenticationCheck how accounts and browsing data are handledPersistent profiles can support workflows that need retained state
ObservationCheck the product’s available review and supervision featuresA live viewer can help operators inspect a session
Operational limitsCheck current product terms and availabilityCheck session limits, usage controls, and current pricing

This table compares product categories, not a feature-by-feature audit of Fellou. It does not establish that Fellou lacks APIs, remote execution, or any other capability. Verify the specific interfaces and terms you need with the vendor.

For more context on the infrastructure side, see remote browsers for AI agents.

Choose based on the workflow, not the label

“AI browser” can describe a user-facing application, an agent framework, or the browser infrastructure underneath an agent. Those layers solve different problems.

Use an AI-oriented browser for supervised individual work

Fellou AI browser is worth evaluating when the person doing the work is also the person supervising it. For example, a researcher might want help finding information across websites, then review the sources and decide what to include in a report.

In this setting, the most important evaluation criteria are often:

  1. Quality of the result. Are the sources relevant, and can the user verify claims?
  2. Control over actions. Can the user stop, inspect, and correct the workflow?
  3. Privacy and permissions. What page content or account information can the assistant access?
  4. Recovery. Can the person resume when a site presents an unexpected page?
  5. Everyday usability. Does the workflow save time after review and correction?

Use a test set of real tasks rather than relying on a product demo. Include at least one task with multiple sources, one authenticated workflow if permitted, and one page with ambiguous or changing content. Do not use sensitive accounts or data until you understand the product’s handling policies.

Use a hosted runtime for application-owned workflows

A hosted runtime is a better starting point when the browser is part of software you operate. Examples include a scheduled internal portal check, an agent that collects information for a support workflow, or a QA job that tests a web application from a cloud worker.

Here the application, rather than a person’s browser window, needs to coordinate the work:

  1. Obtain an authorized browser session and its connection information.
  2. Connect an automation client or agent to that session.
  3. Navigate, extract data, or perform permitted actions.
  4. Record enough context to diagnose failures without exposing secrets.
  5. Close pages and follow the provider’s session-termination process.

Remote Browser supplies the browser runtime; your application still owns the task logic, model selection if an AI agent is involved, authorization, and decisions about what actions are allowed. Hosting Chromium does not automatically make an agent accurate or grant permission to automate a third-party site.

Use both only when the boundaries are clear

A team might use Fellou AI browser for individual research and a hosted runtime for a separate automated workflow. Treat them as separate systems unless their current documentation explicitly supports an integration.

Do not assume that a Fellou login, desktop profile, active tab, or agent can be attached to Remote Browser. Moving a workflow between products generally means recreating the automation and establishing authentication in the destination environment through an approved process.

Production criteria for browser-based agents

If a Fellou workflow is a useful prototype, it can reveal what an automated service needs to do. Before translating it into code, document the following boundaries.

Session ownership and isolation

Decide whether each job needs a fresh session or access to a retained profile. A fresh session reduces accidental sharing of browser state between runs. A persistent profile can be useful for an authorized recurring workflow, but it also creates a valuable asset that needs access controls and a lifecycle.

For multi-user applications, map sessions and profiles to the correct tenant. Do not reuse a profile across unrelated customers merely to avoid repeated sign-ins. Check the runtime’s isolation model, retention settings, and concurrent-session limits against your requirements.

Authentication and sensitive data

A login session can give automation the same access as the account owner. Use dedicated accounts with the minimum necessary permissions where possible. Store credentials in a secrets manager rather than source code, and avoid recording passwords, session cookies, or authenticated page contents in routine logs.

Plan for expired sessions and human verification. If a site requires a person to complete a login or approval step, design a handoff rather than treating the interruption as a failure to bypass.

Review and observability

A final answer alone rarely explains why a browser task failed. Capture practical diagnostic signals, such as:

  • The workflow and session identifier.
  • The last completed step and a sanitized error message.
  • Navigation and operation timeouts.
  • Whether a human review or authentication step was required.
  • A screenshot or recording only when permitted by your data policy.

Remote Browser’s live viewer can help an operator inspect what a session is doing. Decide who may access that view and how long diagnostic artifacts should be retained. A viewer is useful for investigation, but it is not a substitute for application-level audit logs.

Limits and cost

Measure browser time per completed task, not just the number of agent requests. A workflow may keep a browser session open while waiting for a model response or a human approval. Retries and abandoned sessions can also affect usage.

Set timeouts and cleanup rules appropriate to the workflow. Check current pricing and usage limits before estimating costs; do not assume that every plan supports the same concurrency or session duration.

Build a hosted Chromium proof of concept

The following example is not a Fellou integration. It demonstrates the alternative architecture: a Node.js application uses Playwright to connect to an already provisioned Chromium session over CDP.

Before running it:

  1. Install Node.js and Playwright in your project.
  2. Provision a Remote Browser session using the current documentation.
  3. Obtain the CDP endpoint for that session and set it as CDP_URL in your environment.
  4. Ensure the session can reach the target site and that your use is authorized.

Install the client package:

npm install playwright

Then save this as remote-check.ts:

import { chromium, type Browser, type Page } from "playwright";

async function main(): Promise<void> {
  const endpoint = process.env.CDP_URL;
  if (!endpoint) {
    throw new Error("Set CDP_URL to your hosted Chromium CDP endpoint.");
  }

  let browser: Browser | undefined;
  let page: Page | undefined;

  try {
    browser = await chromium.connectOverCDP(endpoint, {
      timeout: 30_000,
    });

    // Use the existing context supplied by the remote browser.
    const context = browser.contexts()[0];
    if (!context) {
      throw new Error("The remote browser did not expose a context.");
    }

    page = await context.newPage();
    await page.goto("https://example.com", {
      waitUntil: "domcontentloaded",
      timeout: 30_000,
    });

    const heading = await page.locator("h1").first().textContent();
    console.log({
      url: page.url(),
      heading: heading?.trim() ?? null,
    });
  } finally {
    // Close only the page this script created.
    await page?.close().catch(() => {});
    await browser?.close().catch(() => {});
  }
}

main().catch((error: unknown) => {
  console.error("Browser check failed:", error);
  process.exitCode = 1;
});

Run it with your preferred TypeScript runner, for example after installing tsx:

npm install --save-dev tsx typescript
npx tsx remote-check.ts

Treat the CDP endpoint as a secret: anyone with access to it may be able to control the associated browser session. Do not commit it to a repository or print it in logs. The example uses the existing context and closes its own page; it does not create or delete a persistent profile.

browser.close() disconnects the Playwright client from a connected browser. Follow the provider’s documentation for explicitly ending the hosted session and stopping usage, because client disconnection and provider-side session termination should not be assumed to be the same operation. For protocol details and limitations, see Playwright’s `connectOverCDP` documentation.

Turn the proof of concept into a reliable workflow

Once the connection works, replace the example page with a permitted test workflow. Start with a read-only task before allowing an agent to submit forms or modify records.

A practical rollout sequence is:

  1. Define success precisely. For a portal check, specify the fields to extract and how fresh the data must be.
  2. Separate observation from action. Let the agent read and propose changes before granting it permission to submit them.
  3. Add explicit waits and timeouts. Wait for meaningful page elements rather than relying on arbitrary sleeps.
  4. Handle known interruption states. Detect expired logins, missing permissions, and verification pages; route them for review.
  5. Test cleanup. Confirm what happens to pages, sessions, and retained profiles after success, failure, and worker termination.
  6. Measure outcomes. Track completed tasks, human interventions, retries, and browser time alongside error categories.

For dynamic pages, use stable selectors and check the expected page state before taking action. If an AI model chooses the next step, validate high-impact operations against application rules. A confirmation step is especially important for payments, messages, deletions, and other actions that are difficult to reverse.

See remote browser automation for more on controlling browser sessions from code and agents.

The practical choice

Evaluate Fellou AI browser when your immediate need is a person-centered AI browsing experience. Judge it by the quality of its assistance, the user’s ability to supervise actions, and its current privacy and product terms.

Choose a hosted Chromium runtime when the browser must become an operational component of an application: connected from code, managed across jobs, and inspected when something goes wrong. Remote Browser provides that runtime; it does not replace the agent logic or authorization policies you build around it. Start with the documentation, run a read-only test, and validate session cleanup and security before expanding the workflow.