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.
Open AI Copilot
Open Copilot from the project-level operations in the top navigation bar. The panel can be docked beside the editor or floated above it — switch with Dock panel and Floating panel in the panel header.
Alongside text, you can attach an image to a message — a screenshot of a layout you want, or a recording of a problem. Images are limited to 20 MB.
Who can use AI Copilot
AI Copilot needs collaborator access above Viewer, on the project or on the app you have open, and it is unavailable once the project has expired. App-level access takes precedence over project-level access, so an editor on one app has Copilot there even without a project-level grant.
The entry stays in the header either way. When Copilot is unavailable the button is disabled rather than hidden, and its tooltip says which of the three reasons applies.
Research mode and Build mode
AI Copilot works in two modes, switched from Mode in the panel header:
| 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 directly | ”Create an Order table and an Actionflow that submits an order” |
Use Research to understand a project or agree on a design, then switch to Build to carry it out.
Approve the plan before work starts
In Build mode, anything beyond a small change begins with a Suggested plan — the Business goals it understood, and the Execution steps it intends to take. Nothing is written to the project until you respond:
- Approve and start — AI Copilot begins building. Approving a plan also switches the session to Auto accept, so the changes in that plan are applied as they are made rather than waiting for individual confirmation.
- Request changes — send feedback describing what should be different, and AI Copilot revises the plan.
Reviewing the plan is the cheapest place to correct a misunderstanding, since no resources have been created yet.
Review proposed changes
Outside Auto accept, each change AI Copilot wants to make appears as a Proposed change that you can Confirm or Reject. Switch to Auto accept at any point to let a run continue without stopping at each step.
Send while a run is in progress
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.
During a run the composer has two separate buttons. Send always sends, and a Stop the current step button 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.
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.
What this session can change
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, 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.
A person icon sits at the left of the toolbar above the composer. Open it for this session’s two fields: Editable scope (Project or Frontend only) and Backend access role (Admin or End user). The three cases above are Project + Admin, Frontend only + Admin, and Frontend only + End user. Nothing shows before the session’s first run, when neither field has been resolved yet.
Both fields are pinned on the session’s first run and never widen afterwards. The two narrowings have different causes. Editable scope dropping to Frontend only is a matter of where you are — your permissions are fine, so open the project’s backend app and start a session there. Backend access role dropping to End user is a matter of permission: the gate is project-level edit access, so switching app will not widen it.
Tools outside a session’s scope are never offered to it, and a request for one is refused with the reason rather than half-attempted. To make a backend change, open the project’s backend app and start a session there.
Sibling client apps are not part of the session: AI Copilot can neither read nor change their pages. When a request belongs to one of them it names that app and asks you to open it, instead of reading its absent pages as missing.
What AI Copilot can build
Data models
In the Data tab, AI Copilot creates tables, fields, and relations. 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 the Action tab, 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
Also in the Action tab, AI Copilot configures third-party APIs: request method, path, parameters, and response structure, so an external service becomes callable from your project.
Payments
AI Copilot can activate the payment module itself, one gateway at a time (Stripe or Airwallex). The order table has to exist first — you tell AI Copilot which table to use, and it binds it. The order table the first activation binds is fixed: later gateways reuse it, and it cannot be replaced or unbound afterwards, so agree on the order table’s design before activating anything.
The first activation also inserts the three payment system tables (payment_record, recurring_payment, refund) and their relations to your order table, and lists them in every role’s table permissions — with read access granted to the logged-in user role only. Every activation then appends that gateway’s generated Actionflows, callbacks, and scheduled jobs, and grants the logged-in user role permission to start payments through it. AI Copilot names what it created; that matters under Auto accept, where none of it was confirmed step by step.
The rest stays yours, in Action → Payment: the gateway’s merchant credentials, the brand name, logo, and slogan, and the Pro-plan upgrade that payments require. See Payment Overview.
AI Agents
In the AI tab, AI Copilot builds AI Agents — prompts, inputs and outputs, contexts, and tools — producing a working draft Agent you can refine by hand.
Pages and components
In the Design tab, AI Copilot builds pages and components. Describe the layout and interactions you want, and it creates the components, binds them to data, and applies basic styling. This is what makes AI Copilot a full-stack builder rather than a backend one: a feature can go from data model to working screen in a single conversation.
Every resource AI Copilot creates is listed in the session’s created-items summary, grouped by kind — Table, Actionflow, API, and AI Agent. Select any item to jump to it in the corresponding editor and keep working on it yourself.
Follow AI changes
Turn on Follow AI changes 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 use Stop following, to return to manual control.
Verify against the live app
AI Copilot does not only describe its changes — it can check them against your deployed backend:
- Read and count rows in live tables to confirm that data a flow or form should have written is actually there.
- 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.
- 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 and read the resulting conversation.
Signed-out and signed-in usually return different data, and AI Copilot compares them:
| Identity | What it is |
|---|---|
| Anonymous | No credential at all — a logged-out visitor, and the only identity carrying the Anonymous User role |
| Signed in | A real account, signed in with credentials you supply, carrying Logged-in User plus its own project roles |
Only a signed-in account can test a rule that keys on one of your project’s custom roles, so AI Copilot may ask you for a real account’s username and password. It uses them for that sign-in only — whether to hand them over is your call.
- 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 rolls back its 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 to 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.
Builder AI Points
Building with AI Copilot spends Builder 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.
Two controls in the composer affect what a run costs:
- 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
Free points
- Every user, new and existing, receives 500,000 AI Points, valid for 90 days.
- On top of that, 200,000 free points are granted every Monday. Anything left over from the previous week expires when the new grant arrives.
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.
Builder 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. Builder AI Points pay for AI Copilot’s planning and building.