Manifest, Methods, Tables, Roles, Interfaces, Scenarios: The Remy Vocabulary

A Remy app is built from six core primitives, and once you know all six, you can read any Remy app end to end. They are the manifest (mindstudio.json), methods, tables, roles, interfaces, and scenarios. The manifest is the index that ties the other five together: it declares every method, table, role, interface, and scenario the app contains, and the platform reads it to know what to compile and deploy. This glossary defines each one in plain language, with a short readable example, so the vocabulary stops being a wall of jargon.

You don’t write these by hand from scratch. You describe the app you want, Remy drafts the spec, and you read and refine it in plain English. The six terms below are what you’ll see in that spec — and what you’ll talk about when you ask Remy to change something.

TL;DR

• A Remy app has six core building blocks: the manifest, methods, tables, roles, interfaces, and scenarios — learn these and you can read any Remy app.
• The mindstudio.json manifest is the app’s index — it lists every method, table, role, interface, and scenario, and the platform reads it to know what to build and ship.
• Methods are the backend — named async functions that hold all the real logic; every way a user touches the app eventually calls a method.
• Tables are the database — each is a typed definition the platform reads to build and migrate the actual SQL schema for you, no migration files to write.
• Roles are access control — named permission groups like “admin” or “approver” that the compiled backend enforces on the server, not just in the UI.
• Interfaces are the front doors — web, REST API, Discord, Telegram, cron, webhook, email, MCP, and a conversational agent, all calling the same methods.
• Scenarios are repeatable seed states — scripts that put the database into a known starting point so you can test or demo a specific situation on demand.

What is the mindstudio.json file in a Remy app?

The mindstudio.json file is the manifest — the app’s index. It declares everything the platform needs to know about the app in one place: which methods exist, which tables make up the database, which roles control access, which interfaces users can reach the app through, and which scenarios are available for testing. When you publish, the platform reads the manifest to figure out what to compile and what to deploy.

Think of it as the table of contents. The manifest doesn’t contain the logic — it points at the files that do. Each method, table, interface, and scenario gets one entry naming its file path and the export the platform should load.

Here’s the shape of a manifest for a small procurement app, in readable form:

{
  "name": "Procure-to-Pay",
  "roles": [
    { "id": "requester", "name": "Requester" },
    { "id": "approver", "name": "Approver" },
    { "id": "admin", "name": "Administrator" }
  ],
  "tables": [
    { "name": "vendors", "path": "...vendors.ts", "export": "Vendors" }
  ],
  "methods": [
    { "id": "submit-vendor-request", "path": "...submitVendorRequest.ts", "export": "submitVendorRequest" }
  ],
  "interfaces": [
    { "type": "web" },
    { "type": "api" }
  ]
}

You rarely edit this by hand. As Remy adds a method or a table to the spec, the manifest entry comes with it. If you want to understand how a plain-language spec becomes this structured app, the three-layer model of spec, backend, and interfaces walks through the full path.

What are methods and tables in Remy?

Methods are the backend. A method is a named async function that runs on the platform — the universal unit of backend logic. Every interface, whether it’s a web form or a Discord command, is just a different way to call a method. The method is where anything real happens: it reads and writes the database, checks permissions, calls AI models, sends email. Methods run in isolated sandboxes, so there are no servers to manage.

A method receives one input object and returns one output object. Here’s one that submits a vendor request:

export async function submitVendorRequest(input: {
  name: string;
  contactEmail: string;
}) {
  auth.requireRole('requester');

  const vendor = await Vendors.push({
    name: input.name,
    contactEmail: input.contactEmail,
    status: 'pending',
  });

  return { vendorId: vendor.id, status: vendor.status };
}

Tables are the database. A table is a typed definition of a record — its columns and their types — that the platform reads to build the real SQL schema. You don’t write CREATE TABLE statements or migration files. The platform reads your TypeScript to extract the schema, and when a column or table changes, it generates and applies the migration automatically. A table looks like this:

interface Vendor {
  name: string;
  contactEmail: string;
  status: 'pending' | 'approved' | 'rejected';
}

export const Vendors = db.defineTable<Vendor>('vendors');

Every table also gets system columns for free — an id, created_at, updated_at, and last_updated_by — maintained for you. Reads and writes use a chainable query API (Vendors.filter(v => v.status === 'approved')) that compiles to SQL. Methods import tables and act on them; that’s the whole backend loop. For a fuller picture of how methods fan out to every front door, see one method, eight interfaces.

What are roles in Remy?

A role is a named permission group — “admin,” “approver,” “requester” — that the compiled backend enforces. Roles are declared in the manifest with an id and a name, and they’re checked server-side inside methods. The point that matters for security: the check happens in the backend, not just in the frontend. Hiding a button in the UI is a convenience; the role gate inside the method is the actual rule.

Auth in Remy is opt-in. Apps that don’t need users run anonymous guest sessions. When an app does need users, you turn on auth, define a user table, and the platform handles verification codes (email or SMS) and sessions. A method gates itself with one line:

auth.requireRole('admin', 'approver');

That throws if the caller isn’t signed in, or is signed in but lacks any of the listed roles. Roles can be set from code (Users.update(userId, { roles: ['admin'] })) or from the dashboard, and the platform keeps the two in sync. Because the rule lives in the compiled backend, a request that skips the UI and hits the method directly is still checked.

What are interfaces in Remy?

An interface is a front door — a way users reach the app. The same methods power all of them. A web app, a Discord bot, and a nightly cron job can all invoke the same backend logic, because interfaces are just projections of the backend into different modalities. Remy supports a wide set out of the box:

Interface	What it is	Typical use
web	A Vite + React web app, hosted for you	The main user-facing app
api	REST endpoints with clean URLs	External services and integrations
discord	Slash commands mapped to methods	Team workflows inside Discord
telegram	Bot commands and messages	Chat-driven tools
cron	Scheduled method runs	Nightly jobs, reminders
webhook	Inbound HTTP endpoints	Stripe, GitHub, Shopify events
email	Inbound email handling	Process mail sent to the app
mcp	Methods exposed as AI tools	External agents calling your app
agent	A built-in conversational agent	A chat assistant over your methods

Each interface is one entry in the manifest. A web interface points at a small config file; an API often needs nothing but its type declared. You don’t rebuild logic per channel — you write the method once and add the front doors you want. Set "enabled": false on any interface to skip it during a build without deleting it.

What is a scenario in Remy?

A scenario is a seed script that puts the database into a specific, known state so you can test or demo a situation on demand. Instead of clicking through the app to manually create the data you need, you run a scenario and land on a repeatable starting point. A scenario is just an async function using the same push() calls a method would — if you can write a method, you can write a scenario.

Each scenario also declares which roles to impersonate after it seeds, so you can see the app from a specific user’s perspective. A scenario for an accounts-payable user staring at two overdue invoices reads like this:

export async function apOverdueInvoices() {
  const vendor = await Vendors.push({ name: 'Acme Corp', status: 'approved' });
  await Invoices.push([
    { vendorId: vendor.id, dueDate: db.ago(db.days(5)), status: 'pending_review' },
    { vendorId: vendor.id, dueDate: db.ago(db.days(2)), status: 'approved' },
  ]);
}

Running it clears the dev database, seeds the rows, and impersonates the declared role. Scenarios are deterministic — the same one always produces the same state — which makes them double as living documentation (“what does the AP dashboard look like with overdue invoices?”), demo data, and a baseline for catching visual regressions across roles.

How the six primitives fit together

Read top to bottom, the six pieces describe a whole app:

• Manifest — the index that names every other piece and tells the platform what to compile.
• Tables — the typed data definitions the platform turns into a real SQL database.
• Methods — the async functions holding all backend logic, reading and writing those tables.
• Roles — the server-enforced permission groups methods check before they act.
• Interfaces — the channels (web, API, Discord, cron, and more) that invoke methods.
• Scenarios — the seed scripts that put the database into a known state for testing.

You don’t assemble these by hand. You describe the app, Remy drafts the spec across all six, and you refine it in plain language. The actual annotation syntax that ties prose to these structures — MindStudio-Flavored Markdown — has its own walkthrough if you want the mechanics. When the spec is ready, you hit Publish and the platform builds the backend, migrates the database, hosts the frontend, syncs the roles and interfaces, and gives you a live URL.

Where Remy fits in the tooling landscape

Today, the most advanced product agent is Remy. Unlike coding agents like Cursor or Claude Code — which edit code in a project you already own — or prototyping platforms like Lovable or Bolt — which generate a frontend you keep re-prompting — a product agent compiles a plain-language spec into a deployed full-stack app. The six primitives in this glossary are exactly what that compile step produces. If you want the category itself defined first, start with what a product agent is.

FAQ

What are the core building blocks of a Remy app? The six core primitives are the manifest (mindstudio.json), methods, tables, roles, interfaces, and scenarios. The manifest indexes the other five and tells the platform what to compile and deploy.

What is the mindstudio.json file? It’s the app manifest — a single file that declares every method, table, role, interface, and scenario in the app. The platform reads it to know what to build and ship.

What is the difference between a method and a table? A table defines a record’s shape so the platform can build the database; a method is the async backend function that reads and writes those tables and holds the app’s logic. Methods import and act on tables.

Do I have to write migrations for tables? No. The platform reads your TypeScript table definitions to extract the schema and applies new tables, added columns, and dropped columns automatically — there are no migration files to write by hand.

Are roles enforced in the frontend or the backend? In the backend. A method calls auth.requireRole(...), and the compiled backend enforces it server-side, so a request that bypasses the UI is still checked. Hiding UI is convenience; the method gate is the real rule.

What interfaces can a Remy app expose? Web, REST API, Discord, Telegram, cron, webhook, email, MCP, and a built-in conversational agent. All of them call the same methods — you write the logic once and add the front doors you need.

What is a scenario used for? Putting the database into a known starting state for testing or demos. A scenario seeds data and impersonates a role, and it’s deterministic — the same scenario always produces the same state.

Do I write these primitives by hand? No. You describe the app and Remy drafts the spec across all six; you read and refine it in plain language. The vocabulary is for reading and discussing the app, not hand-coding it.

The bottom line

Six words give you the whole tool: manifest, methods, tables, roles, interfaces, scenarios. The manifest indexes everything, tables become the database, methods hold the logic, roles guard it server-side, interfaces project it to every channel, and scenarios reset it to a known state. Learn the six and you can read, discuss, and reshape any Remy app in plain language.

Remy is a product agent that compiles annotated markdown into a full-stack app — backend, database, frontend, auth, tests, and deployment — in a single step. See goremy.ai.

Start building with Remy →