Agentic page deployments
for the AI era

GBased everyone, we are proud to announce a follow-on product to Based AI that we have been working on: Based Pages.

We believe the future will not just be agents that think, but agents that ship.

As we move into a world where software agents increasingly make decisions, generate output, and act on behalf of humans, one thing becomes obvious: chat alone is not enough. A wall of text is not the final form of agent output. In many cases, the right output is a live page - a shareable report, a dashboard, a proposal, a landing page, or a single-page application that can actually be used. Based Page is our answer to that future.

That is the thesis of Based Pages. By giving AI a native deployment layer for pages and SPAs, we are turning conversations into live software. Prompt in, live URL out. No pipeline. No friction. No waiting around.

Based Page is built exactly for that. A single conversation can go from idea to deployed site in seconds, with pages going live immediately on their own {slug}.based.page subdomain.

If you are building with ChatGPT, Claude, Cursor, Windsurf, VS Code, or any workflow that can talk to tools, you can plug into Based Page and let your agent deploy directly. The platform is designed to work with any agent, supports multi-file deploys, and includes SPA routing for client-side apps.

Similar to our Based AI gateway, the "Page" product will take on an agentic payment structure via x402 on Hyperliquid - this is in alignment with our bet that Hyperliquid is the de-facto x402 settlement layer for the future.

The AI world has spent a lot of time focusing on generation. Generate text. Generate code. Generate images. But in practice, useful software output often needs one more step: deployment.

That final step has historically been full of friction:

• Set up infrastructure
• Wire up hosting
• Configure domains
• Create accounts and pass API keys
• Manage build pipelines
• And only then, maybe, get something live

Agents need a way to go from thought to artifact without getting trapped in operational overhead. That is why Based Pages exists. It gives agents a deploy button.

The conversation itself becomes the shipping pipeline. We think this matters a lot more than it might seem at first. Because once agents can deploy, they will be able to go from one prompt into a product you can immediately use, or share.

A lot of agent output is simply better as a page.

Not everything should live inside chat bubbles. A quarterly report should look like a quarterly report. A proposal should feel polished. A dashboard should be interactive. An internal tool should behave like software, not like pasted text in a conversation.

This is where we think a lot of the market is going:

• Agents will generate structured outputs
• Those outputs will need to be reviewed, shared, and interacted with
• Live pages will become a default interface for agent-created work

Based Page takes that seriously. Instead of forcing generated work back into chat, it lets agents publish polished artifacts directly.

Based Page is not just a static HTML host. It is a deployment layer built for agents, frameworks, and teams. The product supports single HTML pages, multi-file sites, and framework-based apps that compile to static files.

The mental model is straightforward:

1. Tell your agent what to build
2. Let it generate the files
3. Let it deploy to a live URL instantly

No traditional build pipeline required for many common use cases. The docs support React and framework-style apps via CDN patterns, including no-build-step flows using imports from esm.sh and is_spa for client-side routing.

It is not asking agents to become DevOps engineers. It is giving them a path to ship.

One of the most important choices we made with Based Page is removing the usual setup burden.

Your agent can deploy without an account. No signup. No API key. No complicated onboarding. Pages go live instantly, and later, when you want more control, you can log in and claim them. From there, you unlock dashboard features like version history, archives, and form analytics.

It should feel obvious:

• Ask the agent to build
• Get a live link back
• Share it instantly

That is the kind of product experience that makes agentic workflows actually stick.

Not every page should be public to the whole world. Some pages are early previews. Some are internal dashboards. Some are client-facing but not meant for open access.

Based Page supports password protection and token-based share links, with the ability to revoke access when needed. This makes it useful not just for public launch pages, but also for:

• Review this internally
• Share this with one client
• Circulate this only within a team
• Send this preview before launch

Based Page is built to handle both the public and private side of that workflow.

We believe the agentic future requires a few foundational primitives:

1. Agents need a way to create useful artifacts
2. Those artifacts need to be deployed instantly
3. The resulting outputs need to be shareable, interactive, and easy to manage

Based Page sits at that intersection.

That may sound simple, but we think it is a very important step in how software gets made from here. A lot of software creation will begin as a conversation. A meaningful percentage of frontends, microsites, reports, dashboards, and internal tools will be generated through agent workflows.

When that happens, the deployment layer becomes part of the product itself. Based Page is our way of building that layer. But more importantly, building this gives us a new Lego piece which we are using to power the future direction we're bringing Based into.

As we continue scaling up our goal of "Trade Everything, Spend Everywhere" on the House of All Finance, we are also very aware that AI is reshaping how humans create, decide, and transact.

For the Based team, this means we need to build a future where we are the ones capitalizing on this AI revolution where humans are increasingly delegating thoughts and decisions to AI. To do this, we have a planned roadmap. The following are our first two small steps:

• With Based AI, we placed a bet on commoditized intelligence.
• With Based Page, we are placing a bet on commoditized deployment.

We think the future becomes obvious once you see it: agents simply need a better way to present information - and that's a webpage. We also believe that AI will choose the cheapest, fastest, most neutral platform to pay for such services - and that's Hyperliquid.