Page Agent: A JavaScript In-Page GUI Agent for Web Automation Without Browser Extensions

The Problem Page Agent Solves

Most web automation tools operate from outside the browser. They require a Python runtime, a headless browser such as Playwright or Puppeteer, or a browser extension installed on the user's machine. Each of these adds setup friction and is difficult to ship as part of a hosted web product.

Page Agent takes a different position: all automation runs inside the existing webpage as plain JavaScript. There is no extension to install, no Python dependency, no headless browser process. According to the README, everything happens in the web page itself.

This design makes Page Agent suited for teams that want to ship an AI copilot feature in a SaaS product without adding infrastructure. The README names smart form filling for ERP, CRM, and admin systems as a target use case, alongside accessibility applications where natural language commands replace multi-click workflows.

Text-Based DOM Manipulation Instead of Screenshots

Many in-browser AI agents work by taking a screenshot, sending it to a multimodal model, and then interpreting the model's instructions as DOM actions. Page Agent does not use screenshots. It processes the DOM as text.

The README describes this as text-based DOM manipulation with no screenshots and no multi-modal LLMs or special permissions needed. This has a direct practical effect: it makes the library compatible with models that have no vision capability, and it avoids the latency of capturing and uploading a screenshot on every action step.

The DOM processing components and prompt design are derived from the browser-use project (github.com/browser-use/browser-use), which the README acknowledges explicitly. The README states: "DOM processing components and prompt are derived from browser-use: Browser Use <https://github.com/browser-use/browser-use>, Copyright (c) 2024 Gregor Zunic, Licensed under the MIT License."

Installing and Running a First Automation

For evaluation, the fastest option is a single script tag that loads the demo build from a CDN:

<script
    src="https://cdn.jsdelivr.net/npm/[email protected]/dist/iife/page-agent.demo.js"
    crossorigin="anonymous"
></script>

The README warns that this demo CDN uses a free testing LLM API intended for technical evaluation only, not production use.

For production use, install via npm:

npm install page-agent

Then import and instantiate the agent with your own LLM credentials:

import { PageAgent } from 'page-agent'

const agent = new PageAgent({
    model: 'qwen3.5-plus',
    baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
    apiKey: 'YOUR_API_KEY',
    language: 'en-US',
})

await agent.execute('Click the login button')

The constructor takes `model`, `baseURL`, `apiKey`, and `language`. The `baseURL` accepts any OpenAI-compatible endpoint, which is how it supports locally deployed models alongside cloud providers.

Multi-Page Tasks via the Chrome Extension and MCP Server

The base library handles automation within a single page. For tasks that span multiple browser tabs or require coordination across different URLs, Page Agent provides an optional Chrome extension listed in the Chrome Web Store with extension ID `akldabonmimlicnjlflnapfeklbfemhj`.

The README also mentions an MCP Server in beta that allows agent clients to control the browser from outside the page. This is a different integration model from the in-page library: where the core library runs inside the webpage, the MCP Server exposes browser control as a tool that an external agent can call.

The monorepo is organized as a set of npm workspaces. The root `package.json` lists these packages: `page-controller`, `ui`, `llms`, `core`, `page-agent`, `mcp`, `extension`, and `website`. The separation between `core` and `page-agent` suggests that the DOM processing logic is in a shared package consumed by both the main library and the extension.

Supported Models and the Bring-Your-Own-LLM Constraint

Page Agent works with most mainstream models, including locally deployed ones, according to the README. The documentation site lists supported models at `alibaba.github.io/page-agent/docs/features/models`.

The constructor's `baseURL` parameter accepts any OpenAI-compatible endpoint. The example in the README uses `dashscope.aliyuncs.com/compatible-mode/v1` with `qwen3.5-plus`, which is a Qwen model served through Alibaba Cloud's DashScope API. A developer using a locally deployed model through Ollama or LM Studio could point `baseURL` at their local server if that server exposes an OpenAI-compatible API.

The free demo CDN uses a testing LLM API with its own terms, documented at the Page Agent terms-and-privacy page. The README's warning is clear: it is for technical evaluation only. Any production deployment requires the developer to supply credentials for a supported model.

Limitations and Cases Where Page Agent Is the Wrong Tool

Page Agent is explicitly not designed for server-side automation. The README states: "PageAgent is designed for client-side web enhancement, not server-side automation." If you need to automate a website from a server process, tools like Playwright or browser-use are the appropriate choice.

The library also has no built-in handling for pages that use heavy canvas rendering, PDF viewers, or iframe-heavy layouts where text-based DOM access is limited. The README does not document how the agent behaves on these page types.

Contributions generated entirely by bots or AI without substantial human involvement are not accepted, according to the README. This is a stated policy constraint for the project, not a technical limitation, but it is relevant for teams evaluating whether they can submit automated patches.

The project requires Node.js 22.22.1 or later, or Node.js 24 or later. The root `package.json` sets `engines: { node: "^22.22.1 || >=24" }`. Environments running older Node.js versions will need to upgrade before using the library.

License, Maintenance, and Project State

Page Agent is licensed under MIT. The DOM processing components derived from browser-use are also MIT-licensed, as noted in the README attribution block. There are no license compatibility issues for commercial use of either the library or its browser-use-derived components.

The most recent release is v1.12.4, published on 2026-09-06. The last push to the repository was on 2026-09-21. The project is not archived. Earlier releases in this series include v1.12.3 from 2026-09-05 and v1.12.2 from 2026-07-16, indicating a consistent release cadence in mid-2026.

The repository uses Husky for git hooks and commitlint for commit message validation. The CI pipeline is defined in `.github/workflows/main-ci.yml`. Testing is done through npm workspaces, with each package running its own test suite.

Editorial conclusion

Page Agent suits frontend developers who need to add AI-driven automation to a web application without changing the server or installing a browser extension. The library works client-side, so it integrates with any existing web stack through a script tag or npm package. It is not suited for server-side automation pipelines, which is a stated design constraint: the README explicitly notes that PageAgent is designed for client-side web enhancement, not server-side automation. Before adopting it, check the supported models list at the documentation site to confirm your LLM is compatible. The latest release is v1.12.4 from 2026-09-06 and the last push was on 2026-09-21, so the project is under active development.

Frequently asked questions

Official sources

1. alibaba/page-agent on GitHub
2. License: MIT
3. Project website
4. README
5. Releases