The agent-era app platform

Your whole app, already running.

Build it with the AI coding tool you already use. Forge is the platform underneath that runs all of it: the interface, the data, the security, the hosting, the moment your agent ships.

Read the docs Sign in

Bring your own AI. Keep your own bill.

ClaudeCursorCopilotany MCP agent

Live derivation

One engine, not a supply chain

what you're really replacing

That one declaration replaces a whole stack of separated systems. Each is billed alone, fails alone, and charges you to move data between them.

The wrapper stack

FORGE.

Postgres + Redis + a functions runtime + a CDN — four bills, four failure modes

One engine: storage, API, cache, and render in a single substrate

Auth bolted on; the ownership check lives in a handler someone can forget

Row-level security compiled into every query, with no handler to forget

A CDN and a Redis tier to make reads fast, operated separately

A runtime-native render cache, invalidated by the changelog, with nothing to operate

Hand-build an MCP server over your REST API, then re-implement auth in it

The MCP tool surface is auto-derived, and your row-security already holds on the agent's calls

Everything below the line, derived

no glue code, by construction

Security, compiled in

Row-level rules compile into the read and write path itself. There is no unguarded query, because there is no second path around the one Forge generates.

Row-level security One API, every protocol

The same declaration serves REST, an MCP tool surface for agents, and WebSocket subscriptions, with OpenAPI and AsyncAPI derived, never hand-written.

The multi-protocol surface Deploys you can trust

Every deploy is a content-addressed manifest with a semantic diff and a working one-click rollback. You ship the change, not a leap of faith.

Deploys & rollback

REST

CRUD verbs, OpenAPI

MCP

Tools for agents

WebSocket

Live subscriptions

AsyncAPI

Schemas, derived

Built for what's giving the orders now

the agent issues intent

A model can drive your data and still never cross a line

The thing building software now issues intent, not SQL. On Forge, every table is already an MCP tool with no server to write, and the access rule is compiled into the query, not the transport. So an agent calling over MCP inherits the exact same boundary as a browser over REST.

How row-security travels edge-to-row

Live · agent calling over MCP

tools/call · invoices.list

// the agent issues intent. no SQL, no client library
agent ▸ call "invoices.list" { status: "unpaid" }
// Forge compiles the caller's row-security into the query.
// the agent cannot widen it. only the caller's rows return.
rls ▸ tenant_id = caller.tenant  (injected, not optional)
200 → 3 rows  # of 9,412 in the table

Everything it took a team. None of the team.

the work of a department, by one person and an agent

What it used to take

A database admin
A backend team
A frontend team
A security reviewer
A devops engineer

What it takes on Forge

You
The AI coding tool you already use
Forge, running everything underneath

The database is thirty. The thing building software is one year old.

The old king is dead. We built the kingdom.

The incumbents are wrappers around engines older than the web. Forge wrote its own, top to bottom. You bring the AI; Forge runs everything it builds, secured and live, with no stack to assemble and no team to hire.

Read the docs See pricing