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.

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 synced 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.

Verify against the live app

What it can check

AI Copilot does not only describe its changes — it can check them against your synced 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 synced 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:

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 backend 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 on the dev backend in a multi-client project. Everything the backend app can do: it builds that app’s pages and components, and it can also change and sync the backend.
• A client app on the live backend in a multi-client project. Pages, components and data bindings for that app. The backend it works against is the synced 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. To see which backend version a client uses, see Choose the backend version a client uses.
• App-level access without backend access. The same page, component and data-binding scope. Against the live app it can act only as an identity it obtained itself, never through the admin channel, and it cannot read runtime logs.

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:

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.

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.

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.

Memory and agent files

AI Copilot keeps what it should remember across sessions as agent files: your preferences, the project’s decisions and conventions, where external references live, and standing instructions every session follows. Each new session reads the AGENTS.md files (standing instructions) and sees a list of every file with a one-line description, then opens individual files when it needs them.

Open the agent files panel

The entry is the Agent files icon at the right of the editor’s top bar (inside More when the bar is narrow). When AI Copilot writes or renames a file during a turn, a link such as wrote /project/… appears under that turn’s tool summary; select it to open the file.

You can also manage your own files without opening a project, on the AI Copilot page of your account center. Its Files tab lists only files in the Me (/user) scope; project and client app files stay in the editor. Its Skills tab lists, adds and imports your own skills, and Edit in Agent files in a skill’s details switches back to Files with that file open.

Scopes

The left column of the panel is organized by scope:

Each scope is split into four sections by purpose, plus a Deleted list where you can view and restore deleted files:

Create and edit

Select + on a section’s title to open a blank file in the right column; nothing is saved until you select Create. Memories and skills need only a name and description (plus a type for memories), and their paths are derived: memory/<type>_<name>.md for a memory and skills/<name>/SKILL.md for a skill, whose name may use only lowercase letters, digits and hyphens. For docs you enter the path yourself, and any folders in it are created with the file. To add a file inside a skill or docs folder, such as a script or reference for a skill, hover the folder and select its +.

The name and description of memories and skills appear as a form at the top, so you never edit YAML by hand; other files are edited as plain text. The description is what the AI uses to decide when to read a file, so the panel warns when it is empty.

Memory has four types: user (about the person), feedback (corrections and confirmed approaches), project (decisions and conventions), and reference (where external things are). The memory list is grouped by type, with any missing or unrecognized type under Other.

Files and folders can be renamed, moved and deleted. When a memory’s type no longer matches its file name prefix, the panel offers a one-click rename.

History and restore

The right column lists every version with a line-by-line diff and a Restore button. Restoring writes a new version, so the content it replaces stays in history. A file’s history follows it across renames and moves. Deleted files can be restored from the Deleted list.

Permissions and limits

• You can always edit files under /user. /project needs edit access to the project, and a client app folder needs edit access to that app. Without it, the panel is read-only.
• A file can be at most 256 KB. A project holds at most 500 files and 10 MB in total, and each person’s /user at most 200 files and 10 MB.
• The last 10 versions of each path are kept.

Editing alongside the AI and collaborators

The panel updates live: when the AI or a collaborator changes a file, the list and the open file refresh. If someone changes a file while you have unsaved edits to it, the panel tells you and offers View changes, Reload (discard yours), and Keep mine (save over theirs; their version stays in history).

A running AI Copilot session is told about your changes on its next turn and treats them as your decision, so it does not change them back on its own.

Unsaved edits are kept in this browser, so closing the panel or reloading the page does not lose them. When you reopen the file and nobody has changed it, the panel shows Restored your unsaved changes with a Discard changes button; if it has changed, it is handled as above.

Subagents (parallel research)

For broad questions that can be split up, AI Copilot can send out up to 10 subagents at once to research in parallel. Each subagent has its own conversation and context and sees only the assignment it was given.

• Progress: the progress area lists each subagent’s number, label, state and latest update. The states are working, reported, cancelled, out of budget, out of AI points, failed, stopped and lost in a restart.
• No project changes: subagents can look at the project and read and write agent files, but they do not change the project; when a fix is needed, they report what it would take.
• While they work: you can keep talking to AI Copilot, and it can cancel or steer a subagent by its number. Until every subagent has finished, it does not change the project or write files.
• Limits: each subagent gets up to 50 turns and 5 minutes. When it runs out, it says so, and AI Copilot can give it more budget to keep looking.

Only AI Copilot’s main conversation sends out subagents; focused tasks started from elsewhere in the editor do not.

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 AI Copilot sends out subagents, everything they spend is charged to the request that started them, so broad questions cost more than narrow ones. If the points run out, the subagents stop early and say why.

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.

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 · Transfer project AI points to Copilot.

Related documentation

• Bring your own AI coding tool
• Develop with Run Code
• My Wallet · Copilot AI Points
• Manage Project Resources