Comet goes free and makes your browser the agent runtime

The week the browser became the agent

Perplexity just took the governor off its AI‑native browser. Comet is now free for everyone, shifting the conversation from chatbot interfaces to the place where people actually do things online: the browser. That may sound cosmetic, like moving the AI from one window to another. It is not. Making the browser the default runtime for agents changes both what agents can do and how they get paid for doing it.

If chat was the lobby, the browser is the factory floor. You already authenticate there, your tabs hold the materials, and the page itself is a programmable surface. Giving an agent first‑class citizenship in that environment collapses context switching and turns everyday browsing into task execution.

The browser is not a page viewer anymore. It is a programmable surface where goals turn into actions.

This piece argues the browser will beat chat apps as the agent runtime, explains why Comet’s agent‑first model matters, and compares it with Gemini in Chrome, Arc’s Dia, and Opera’s Neon. We then examine how Comet’s monetization and APIs could reshape search, ads, and affiliate flows. Finally, we forecast what the browser will look like in 2026 and offer a builder’s playbook with concrete steps and metrics.

Why the browser wins over chat apps

Think about the last complex thing you did online. You juggled tabs, copied confirmation numbers, signed in to a few accounts, and probably used autofill. A chat app can describe these steps. A browser agent can perform them.

Here is the structural advantage:

• Session context is native: cookies, tokens, and logged‑in state already live in the browser, not in a remote agent sandbox. That is the difference between suggested steps and one‑click do it.
• The page is an interface, not just a document: the Document Object Model is a live control surface. An agent can click, type, select, and submit without brittle screen scraping.
• Security and consent are legible: permissions like camera, location, clipboard, and payments have established prompts and revocation paths. Agents can borrow those controls instead of inventing new ones.
• Ecosystem reach is built in: extensions, password managers, and wallet integrations can graduate from passive helpers to agent tools.

Put differently, the browser already contains the scaffolding agents need to act. Chat‑first interfaces must bolt that on or keep humans in the loop as the clicker.

Comet’s model: the browser as agent runtime

Comet treats the browser as an operating system for agents. Its assistant travels with you as you shop, plan trips, organize research, and fill forms. Unlike a chat pane that summarizes pages, Comet is designed to complete multi‑step jobs that span multiple sites. The focus is outcome over answer.

Two decisions make this launch consequential:

• Free core, paid rails: Comet is now free, while a low‑cost Comet Plus subscription funds content and features. This product mix invites mass usage while giving publishers a reason to participate.
• Open surfaces for developers: Perplexity’s real‑time Search API, known as Sonar, lets third parties build apps that feed on live web information with citations and streaming output. That is the oxygen agents need for timely, verifiable actions.

In short, Comet positions the browser as both a runtime and a distribution channel for agentic experiences. For adjacent stacks that will be needed in production, see our overview of the agent observability control plane.

How rivals are organizing their agent stacks

• Google: Gemini in Chrome
  Google is putting Gemini directly into Chrome with a toolbar entry point, multi‑tab awareness, and integrations with Calendar, YouTube, and Maps. The company says agentic capabilities that act on web pages are coming in the coming months for desktop and mobile users in the United States. See Google’s outline in its Chrome AI feature update.

• The Browser Company: Dia
  Dia is an AI‑first browser where the address bar doubles as an agent console. Skills let users codify repeatable actions. An optional paid tier removes usage caps. The company’s shift from Arc to Dia, and its acquisition by Atlassian in September 2025, signals a bet that work software and browsers will converge around task flows, not just tabs. For a broader enterprise angle, compare with Office as agent runtime.

• Opera: Neon
  Neon frames itself as an agentic browser for power users. Tasks group related tabs into workspaces. Cards save reusable agent instructions. Neon Do can navigate, fill forms, and coordinate across tabs locally, which appeals to users who want sensitive actions to run on device. Neon’s subscription gate suggests some agent features will live behind a paywall while the company learns what users actually do with an agentic browser.

Across these launches we see convergence on the same primitives: context‑aware workspaces, reusable instructions, and page‑level actions. Positioning differs. Chrome leans on distribution and app integrations. Dia leans on opinionated agent interactions. Neon leans on local execution and power‑user control. Comet leans on search‑native agents and a revenue model that tries to bring publishers along.

Follow the money: Comet Plus and the new payout graph

Making agents mainstream requires a monetization story that pays everyone who creates value. Perplexity is trying to build that bridge with Comet Plus, a five‑dollar subscription whose revenue is pooled and shared with participating publishers. The allocation is based on three signals that mirror how the web now gets used:

1. Human visits by Comet users
2. Citations when Comet answers rely on publisher content
3. Agent actions that use publisher pages to complete a task

Early reporting indicates publishers receive the majority of revenue, with the remainder covering compute and operations. The important part is not the exact percentage. It is the mechanism. Instead of counting only clicks, the model counts contribution to outcomes. If an agent buys a stroller using a review site’s research, that site participates in the revenue even if no human eyeballs the page. That breaks from traditional affiliate flows that rewarded last‑click attribution over earlier influence. See related implications in agentic commerce with ChatGPT checkout.

Expect this to ripple into advertising:

• Action credits replace impressions: brands pay for the agent performing a thing, like booking a service or completing a cart, not merely showing a banner.
• Verified intent replaces keyword guessing: when a browser agent owns the task context, it can route offers based on the actual job, not a string typed into a search box.
• Funnel compression: research, comparison, and checkout can collapse into a single agentic flow inside the browser. The winner will be whoever provides the cleanest handoff from agent to merchant with verifiable completion.

APIs are the plumbing for this economy. A real‑time search API with streaming and citations lets agents explain their choices and attribute sources. An actions API with permissions and receipts lets merchants trust that a purchase came from a specific agent workflow. Together, they support clearer economics than the opaque mix of cookies, pixels, and last‑click lore.

2026 forecast: what changes in the browser

• Tabs become tasks
  The row of squished favicons gives way to containers that remember your goal. A school application task keeps your essay drafts, recommendation requests, scholarship docs, and college sites in one place. The agent knows the finish line and shows progress, not just pages.

• Extensions become MCP‑powered tools
  Instead of monolithic extensions, capabilities are exposed as standardized connectors the agent can request with scoped permissions. The Model Context Protocol turns a password manager, a calendar, or a warehouse system into swappable tools. Your agent adds and drops tools as tasks demand.

• Default browser wars reignite
  Default choice dialogs matter again because the default agent will live inside the default browser. Expect marketing that resembles the mobile keyboard wars: speed, security, and what tools are available to the agent out of the box. Also expect enterprise administrators to standardize on a browser based on policy control over agent permissions.

• Affiliate and search reshape into agent marketplaces
  Publishers and merchants list agent‑readable offers. Agents broker the best path for the user and share fees transparently. Reviews regain value because they influence agent choices, not just human clicks.

• Checkout turns into a capability, not a page
  The browser agent uses a trusted wallet and standardized consent prompts to complete purchases inside the same task context, with receipts written back to your personal archive.

A builder’s playbook

If you build software, content, or commerce, agents in the browser change your job this year. Here are concrete moves to make now.

1. Ship connectors for your data and actions

• Build Model Context Protocol servers or equivalent connectors for your product. Expose read scopes for content and write scopes for actions like create ticket, place order, add to calendar, or generate invoice. Keep scopes narrow and rotatable.
• Provide a permissions manifest that states exactly what the tool can do and what it logs. Offer a test mode that simulates actions for development and demos.

2. Design consent that users actually understand

• Use layered prompts: a one‑line summary followed by a terse list of fields the agent will touch. Offer a live preview whenever possible before the agent submits a form or payment.
• Give users a playback log of agent actions inside each task. Make it easy to revoke a tool or replay an action with different parameters.

3. Instrument outcome‑first analytics

• Track action success rate by task type, not generic dwell time. Time to first success beats time on page as a north‑star metric for agent flows.
• Emit verifiable receipts for completed actions to the browser, with anonymized, signed metadata that publishers and merchants can audit.

4. Build checkout hooks

• Add agent‑friendly checkout endpoints that accept tokenized identities from the browser with minimal redirects. Support partial fills so an agent can place an order with missing options and pause for user approval.
• Return structured outcomes, not just Thank you pages. For example, return order_id, expected_ship_date, and support_contact. Agents need data they can reason about.

5. Publish agent‑readable offers

• If you are a publisher, expose structured offer pages that outline licensing terms for citations or task usage. If you are a merchant, expose structured promotions with eligibility logic. Agents will not scrape fine print; they will parse a contract.

6. Embrace real‑time search in your product

• When your user is making a decision, fetch and ground the interface with current, attributed facts. Agents should be able to show their work using citations without trapping users in a separate chat.

7. Prototype task‑level UX

• Replace generic chat boxes with Play buttons for common jobs. One example: Compare three refrigerators in my cart and pick one by total cost of ownership, then place the order with my store card. Let the user inspect the plan before execution and approve with a single, reversible consent.

KPIs to watch in the agentic browser era

• Agent‑initiated conversion rate: percentage of completed purchases or signups where the agent performed the final action
• Time to successful outcome: median time from task start to verifiable completion, by category
• Action success rate: percent of agent attempts that complete without human rescue
• Publisher revenue per agent task: payout per thousand agent actions that cite or use a publisher’s content
• Tool adoption velocity: number of connectors installed per active user and the retention of those connectors
• Default browser share of agent‑active users: distribution of users whose tasks include at least one agent action in a week
• Consent friction: abandonment rate at consent prompts and average number of prompts per completed task

What could slow this down

• Messy consent: if agent prompts become long and confusing, users will opt out. Keep them short, scannable, and replayable.
• Unclear economics: if publishers cannot forecast revenue from agent actions, they will block crawlers or sue. Revenue pools and explicit action receipts help build trust.
• Brittle automation: agents that fail on common flows will push work back to chat tabs. Invest in fallbacks, partial completion, and human‑in‑the‑loop approvals for risky steps.

The upshot

Comet going free collapses the distance between AI and the place where work actually happens. Gemini moving into Chrome brings agents to the world’s default window on the web. Dia and Neon are pushing the user experience forward with skills, tasks, and local control. The result is not chatbot 2.0. It is a new user interface contract: you set the goal, the browser performs the job, and everyone who contributes value gets paid.

If you are building in this space, treat the browser as your operating system. Give your agent tools a standard connector. Design consent that respects attention. Make checkout a first‑class capability. Measure outcomes, not page views. The winners of 2026 will not be the loudest chatbots. They will be the quietest browsers that get things done.

Additional reading: Google’s rollout details for Gemini in Chrome are in the Chrome AI feature update.