Build with AI Copilot

AI Copilot is the AI builder inside the Momen editor. Describe what you want in natural language, and it plans the work and writes the result directly into your project — tables and relations, Actionflows, third-party APIs, AI Agents, and pages. No local toolchain, no code required.

AI Copilot and Headless · Momen BaaS solve different problems. Headless connects an AI coding tool in your own editor to a Momen backend, and the AI writes frontend code in your codebase. AI Copilot runs inside Momen and configures no-code resources in the project itself, building the frontend and backend together.

What AI Copilot can build

Data models and custom types

In the Data tab, AI Copilot creates tables, fields, and relations, as well as enum and custom object types. This is where it is most effective at one-shot work: describe the business and let it plan the whole structure — users, products, and orders, with the foreign keys that connect them — instead of adding tables one at a time.

It also creates computed (formula) fields — a field whose value is derived from the row’s other fields every time it is read instead of being stored, so it never goes stale. A computed field cannot be required, takes no default value, and cannot use an image, video, file, or JSON type. It is created with an empty formula, which counts as a project error until the formula is filled in, so AI Copilot writes the formula immediately after creating the field. A field can only be switched between stored and computed while it has not been deployed to the backend; after that it has to be deleted and added again. See Formula Reference.

Actionflows

In Action → Actionflow, AI Copilot builds Actionflows, including condition branches, loops, database reads and writes, API calls, and AI nodes. It can compose several nodes into a complete piece of business logic — submit an order, decrement inventory, then send a notification.

Third-party APIs and webhooks

In Action → API, AI Copilot configures third-party APIs — request method, path, parameters, and response structure — so an external service becomes callable from your project. It can also import one from the provider’s online documentation or an OpenAPI/Swagger spec. In an Actionflow’s Triggers, it creates webhooks: HTTP endpoints that fire a given Actionflow when they are called.

Permissions and secrets

In Settings → Permission, AI Copilot designs roles and access control: creating roles and configuring table, column, and row permissions along with Actionflow, API, AI, and payment permissions. Hand it the work whenever a project involves several kinds of user, data isolation, or unexplained 403 errors.

It also registers your project’s secrets — API keys, tokens, and other sensitive values — which Actionflows and API configs then consume by reference. When a value needs to be filled in, the editor prompts you to type it: the plaintext never passes through the conversation, so there is no need to paste a secret to AI Copilot, and you should not.

AI Agents

In Action → AI, AI Copilot builds AI Agents: model, temperature, rounds, prompts, typed input arguments, and plain-text or structured output — producing a working draft Agent you can refine by hand.

Pages and theme

In the Design tab, AI Copilot builds pages and components: creating components, arranging and reordering them, styling them, and binding them to a database query, a page or global variable, or the logged-in user.

Colors, font sizes, and radii can also be made to follow the global theme in Settings → Theme rather than being pinned where they are written, so that changing the theme later carries through everything at once.

At the end of each turn, AI Copilot summarizes what it made as N items created, grouped by Table, Actionflow, API, and AI Agent. Select any item to jump to it in the corresponding editor and keep working on it yourself.

Verify against the live app

What it can check

AI Copilot does not only describe its changes — it can check them against your deployed backend:

Read and count rows in live tables, and where a check needs data to exist first, write it.
Debug-run the draft version of an Actionflow and read every node’s inputs, outputs, duration, and errors — the same debug run the flow debugger performs.
Invoke the deployed version of an Actionflow through the public API, with permissions enforced, to see what a real caller receives.
Execute a snippet of JavaScript in the Run Code sandbox to confirm what a Run Code node will actually return.
Repeat a read as a specific identity to check what it can actually see. Without one, reads use the admin channel, which bypasses row and column permissions.
Sign in to a real account with credentials you supply, and read as that account.
Trial-run a draft AI Agent.
Search the server-side runtime logs (Actionflow, gateway, SQL generation, GraphQL, and more) and follow a single request end to end by its traceId, to pin down an error in the live app.

Before you let it run

Four things are worth knowing before you let it verify against the live app:

⚠️

Live verification runs against the deployed backend. If your draft has unsynced changes, the result does not describe your draft, and AI Copilot says so in its answer.
A debug run and a Run Code trial roll back their database writes when the run ends. Invoking a deployed Actionflow does not roll anything back — its external effects (third-party APIs, emails and SMS, payments) really happen.
Rows written, updated, or deleted in live tables, and any account AI Copilot mints to hold a role, are real, stay in your app, and cannot be undone.
Trial-running a draft AI Agent makes real model calls that spend the project’s AI points and cannot be rolled back.

The limits of a session

A session is bound to the one app you have it open on, and what it can change depends on whether that app carries an editable server schema:

The backend app, or a single-client project. Everything: data model and custom types, Actionflows, permissions, external APIs, webhooks, secrets, AI Agents, theme, payments, and backend sync.
A client app in a multi-client project. Pages, components and data bindings for that app. The backend it works against is the deployed one, so it can run it, debug it and read its logs — but it cannot change any backend configuration, and it cannot sync the backend.
App-level access without backend access. The same page, component and data-binding scope. Against the deployed app it can act only as an identity it obtained itself, never through the admin channel, and it cannot read runtime logs.
Model. The model selector shows each model’s cost multiplier relative to Luna, which is 1 — a model marked 2x spends points twice as fast for the same work.
Effort. How hard the model thinks before answering, from Minimal to Max. Higher effort produces more thorough work and costs more points.

The panel header shows a live balance that turns amber when the balance is low and red when it is nearly gone. When it runs out, building stops with Out of AI Points — your progress is saved and the conversation stays where it is. Top up, wait for the next free grant, or have the project owner transfer project AI Points to the builder.

Balance, usage history, and top-up: My Wallet · Builder AI Points
Transferring a project’s AI Points to the builder: Manage Project Resources

Points move where you need them

A project’s AI Agent AI Points can be converted into the points AI Copilot spends on building, so a balance bought for one purpose is never stranded. See Manage Project Resources.

After the data model, Actionflows, APIs, permissions, secrets, or AI Agents change, the backend has to be synced before what runs online is the new schema. AI Copilot can sync it itself (in sessions whose editable scope is Project), and usually does so before verifying anything against the live app.

Using AI Copilot

Open AI Copilot

The entry is the AI Copilot button at the right of the editor’s top bar, or the ⌘ \ shortcut (Ctrl \ on Windows). Once the panel is open:

The Floating panel / Dock panel icon in the panel header switches between docking beside the editor and floating above it; a floating panel can be dragged and resized.
The same header holds your balance, Follow AI changes, Session history, New session, and the close button.

Choose a mode

Switch modes from the Mode dropdown in the toolbar at the bottom of the composer:

Mode	What it does	Typical use
Research	Answers questions, inspects the current project, and proposes an approach without changing anything	”How should my Order table relate to my User table?”
Build	Creates and modifies project resources, asking you to confirm each change	”Create an Order table and an Actionflow that submits an order”
Auto accept	The same as Build, except changes are applied as they are made rather than confirmed one by one	Once the plan is agreed and you want the whole thing carried out in one go

The usual pattern is to start in Research to understand the project and settle on an approach, then switch to Build and let it work.

Choose a model and effort

The picker in the middle of the composer’s toolbar sets the Model and the Thinking effort (None, Minimal, Low, Medium, High, xHigh, Max) this session runs with. Higher effort means the model reasons further before answering, which usually produces more thorough work and costs more points. The model list shows each model’s cost multiplier relative to Luna, which is 1 — a model marked 2x spends points twice as fast for the same work.

⚠️

Switching to a model from a different provider makes the agent lose its record of the reasoning and tool calls it already made in this conversation; your messages and its replies are kept. A dialog warns you before the switch. Start a new session instead to keep full context.

Send and queue messages

The + at the bottom right of the composer attaches an image to your message — a screenshot of the layout you want, or of the problem you are reporting.

You do not have to wait for a run to finish. Send at any point while AI Copilot is working and the message is queued rather than dropped: it is handed over as soon as the tool call currently in flight completes, so it lands between steps instead of interrupting one.

Queued messages are listed above the composer, marked Queued — sends after the current step. The × beside each one (Remove from the queue) takes it back while it is still waiting. If the agent has already picked the message up by the time you click, removal fails and Copilot says Too late to remove — the agent already has that message — at that point it is part of the conversation, and stopping the run is the only way to change course.

Queued messages are held by the server rather than the browser tab, so anything still waiting is listed again after a page reload or a dropped connection.

Stop the current run

During a run the composer has two separate buttons. Send always sends, and a Stop the current step button (a pause icon) appears next to it. Sending never stops the run, and stopping never depends on whether you have text typed. Pressing Esc stops the run too, while the cursor is in the input box.

⚠️

Stopping discards every queued message the agent has not picked up yet. Anything it already took stays in the conversation.

Follow AI changes

Turn on Follow AI changes in the panel header and the editor navigates to each change as AI Copilot makes it, so you can watch the work happen instead of reconstructing it afterwards. Click anywhere, or select the icon again, to stop following and return to manual control.

Long sessions and reconnects

When a conversation grows long, AI Copilot compacts its context automatically and marks it in the transcript as Context compacted; the session carries on. If the connection drops, the panel shows Connection lost. Reconnecting automatically… and picks the progress back up once it is restored. Keep this browser tab open while it builds — many of the steps are carried out by the editor itself.

Copilot AI Points

Building with AI Copilot spends Copilot AI Points. They belong to your account rather than to one project, so the same balance covers every project you work on. Each message runs one or more model calls, priced from the provider’s published list price.

The balance sits in the panel header and updates as it builds: amber when the balance is low, red when it is nearly gone. Each answer also shows what that turn and the session so far have cost.

When the balance runs out, building stops with Out of Copilot AI Points. Your progress is saved and the conversation stays where it is; top up, wait for the next free grant, or have the project owner transfer project AI points to Copilot, then send your message again to continue.

Balance, usage history, and top-up: My Wallet · Copilot AI Points.
Transferring a project’s AI points to Copilot: Manage Project Resources · Transfer project AI points to Copilot.

Copilot AI Points are not the AI points resource on the project management page. Project AI points pay for AI features inside your published app — AI Agents, vectorization, and vector search. Copilot AI Points pay for AI Copilot’s planning and building.