Your app has a UI for people.
Now it has one for AI agents.
Every published GenMB app can serve its own MCP server. The backend functions you choose become typed tools that ChatGPT, Claude, and any MCP client that supports OAuth or a Bearer token can discover and call. No separate integration to build: write a function, flip it on.
From function to tool in four steps
The agent interface is built from the backend you already have. No SDKs to install, no schema files to maintain.
Write a function
A TypeScript or Python file under functions/ in your app. It already powers your UI; nothing about it changes.
functions/track-order.tsAnnotate it
Add an @description comment and one @param line per input at the top of the file. That becomes the tool description and typed schema.
// @param {string} orderNumberFlip it on
In the Functions panel, turn on "Expose as MCP tool" for that function. Nothing is exposed until you do; every function is off by default.
Expose as MCP tool: onConnect an agent
Point ChatGPT, Claude, or any MCP client that supports OAuth or a Bearer token at your app’s endpoint. Your functions show up as callable tools with real input schemas.
genmb.com/api/mcp/app/{appId}/mcpThe annotation is the integration
Two comment lines at the top of the file become the tool description and a real JSON Schema, parsed from source on every save. The tool name is the function name, verbatim.
functions/track-order.ts// @description Look up an order and its shipping status by order number
// @param {string} orderNumber The number from the confirmation email
// @param {boolean} [includeItems] Also return the line items
import { db } from "./genmb.ts";
export default async function handler(req, ctx) {
const { orderNumber, includeItems } = JSON.parse(req.body);
const order = await db.orders.get(orderNumber);
return { statusCode: 200, body: { order } };
}tools/list{
"name": "track-order",
"description": "Look up an order and its shipping status by order number",
"inputSchema": {
"type": "object",
"properties": {
"orderNumber": { "type": "string",
"description": "The number from the confirmation email" },
"includeItems": { "type": "boolean",
"description": "Also return the line items" }
},
"required": ["orderNumber"]
}
}Works the same in Python: # @description and # @param {string} name at the top of the file.
You decide what agents can touch
Exposing a function is a deliberate act, not a side effect of deploying.
Opt-in per function
Nothing is exposed by default. You flip each function on individually, and you can flip it back off; the change takes effect on the very next agent call.
Typed schemas from source
The tool description and JSON Schema are parsed from the @description and @param annotations in your function on every save. No hand-maintained config to drift out of date.
Optional public listing
Opt into the MCP registry so agents can discover your app. Listing publishes tool names and descriptions plus the endpoint URL, never your source or secrets. Unlisting takes effect within seconds.
Your checks still apply
An exposed function runs as your app’s own backend, with the same validation you wrote and rate limits on top. The platform cannot scope rows for you: a function that never reads ctx.user returns the same data to every caller. Expose the lookups and actions you are comfortable making callable.
Frequently asked
What does it mean for an app to be agent-ready?+
Every GenMB app already has a web UI for people. An agent-ready app also serves its own MCP (Model Context Protocol) endpoint, where the backend functions you opted in appear as callable tools with typed input schemas. ChatGPT, Claude, and any other MCP client that supports OAuth or a Bearer token can discover those tools and call them, without you building a separate API integration.
Which functions become tools?+
Only the ones you choose. Each backend function has an "Expose as MCP tool" switch in the Functions panel, off by default. A function also needs an @description annotation (and one @param line per input) in its source, because that is where the tool description and input schema come from.
How do agents authenticate?+
Each connection is authenticated as a specific person. When an agent connects to your app, its user signs in through your app’s own sign-in page and approves the connection once, so tools run as that person and your ctx.user checks still apply. As the owner you can also connect with a GenMB API key as a Bearer token. Unauthenticated callers get nothing.
How do agents find my app?+
Hand any MCP client that supports OAuth or a Bearer token your app’s endpoint URL directly, or opt into the public MCP registry so it can be browsed. The registry publishes tool names and descriptions plus the endpoint, never function source or secrets, and unlisting takes effect within seconds.
Does this cost extra?+
Exposing a function as a tool is free on every plan, and so is calling it from your own MCP client. Listing the app in the public MCP registry, so other people can find it, needs a paid plan. Browser sign-in from an MCP client is free; manual API keys are a Pro capability. The agent pays for its own inference.
Build once. Serve people and agents.
Describe your app, add a function, flip the switch. The agent interface ships with the app.