How Makesso works.
The technical details: apps and versions, staging and production, data, sharing, the app SDK, AI and limits.
How it works
You describe an app in plain words, or attach data. Makesso's agent designs the data, writes a React app, builds it and checks it runs. Every app is a real web app with a real database, served by Makesso at its own address.
- The agent works in an isolated sandbox that only sees the app it's building. It has no internet access beyond Makesso itself and the package registry, and never holds your API keys.
- Apps are React and TypeScript, built with a modern component library, charts and maps. You can read and edit every line in the Code tab.
- Data lives in datasets: tables in a fast analytical database (DuckDB with DuckLake), with a history of every change.
- Access is checked by the platform on every request, whatever the app's code does. See Security.
Apps and versions
Every change the agent makes is saved as a version. The Versions tab shows them; open one to see what changed, and make any version live again within your plan's history (7 days on Free, 90 days on Pro, unlimited on Team and Business).
Staging and production
On Pro and up, turn on Staging and production for an app in its Versions tab. From then on:
- Production is the live app at its normal address. It runs the version you last published, with the real data.
- Staging is the editor's preview and
…/staging/. It runs the latest version, with synthetic data (see below). - The agent works in staging. Its changes are not live until a person presses Publish; the agent cannot publish.
- Publishing puts the staging version into production in one step. Columns the new version added are created in production, empty; production's data is never replaced. The Versions tab shows which version each environment runs, and the publish history records who published what, when.
- In the Versions tab, every version has → Staging and → Production buttons: put any version into either environment with one click. Deploying to production builds that version on its own, so staging is left as it is; badges show which version each environment runs.
- Turning staging off makes production run the latest version again.
Synthetic staging data
Staging never holds your real data. When staging is turned on, and whenever you press Regenerate staging data, each dataset's staging copy is made from its shape:
- column names, types and descriptions;
- how many rows there are, and the share of empty values;
- the range of numbers and dates;
- for short category columns only (at most 20 distinct values, each used repeatedly, like a status), the category labels.
No names, emails, notes, ids or other values are used or sent anywhere. An AI model (a budget model on the app owner's credits or key) invents believable rows from that shape; the platform then keeps every value inside the shape (ranges, categories) and links rows across datasets, so orders point at staging customers. Without AI available, simple generated values are used instead. Changes in staging, by you, testers or the agent, never touch production, and production's never reach staging.
Testers
Share an app with someone as a Tester to let them use staging (and change its data) without any access to production.
Installable apps
Every app can be installed on phones and computers like a native app: full screen, its own icon, and a friendly offline page. On Android and desktop Chrome or Edge an Install this app button appears; on iPhone use Share → Add to Home Screen. Sign-in works inside the installed app.
Data
A dataset is a table. Every row has _id, _created_at and _updated_at. Import CSV, Excel (including several sheets, title rows and merged headers), JSON or Parquet; new datasets are documented automatically, and links between them (orders → customers) are found and checked against the data.
Kinds of dataset
- App data belongs to an app. Everyone who can use the app uses it, read-only for people with a read share.
- Per-user data: every person using the app gets their own private rows. Nobody else sees them, not even the app's editors.
- Own rows: everyone sees every row and can add rows, but each person can only change or delete the rows they added. Made for leaderboards, guestbooks, comments and votes in public apps. The app's editors can moderate.
- Your data and team data outlive any one app and can be connected to several. An app can never do more with them than its owner could.
SQL
Apps query with DuckDB SQL: joins across datasets, window functions, JSON, dates. The SQL console on the Datasets page runs queries over your own data. Queries can't read files or URLs, attach databases or change server settings, and each runs in its own sandbox that only contains the datasets the person may use.
The app SDK
Apps talk to Makesso through a small SDK. The agent uses it for you; it's documented here for people reading or editing the code.
import { useQuery, useDataset, query, insert, update, upsert, remove } from "appable";
// Live data: re-renders when the data changes, from any tab, person or the agent
const { data, loading } = useQuery<Job>("SELECT * FROM jobs WHERE status = ?", ["open"]);
const { data: todos, insert: add, update: patch, remove: del } = useDataset<Todo>("todos");
await insert("jobs", { title: "Boiler service", status: "open" }); // new keys become columns
await update("jobs", job._id, { status: "done" });
await upsert("settings", { key: "theme", value: "dark" }, "key");
await remove("jobs", { status: "cancelled" });People
import { currentUser, appRole, canWrite, auth, ownerTag } from "appable";
currentUser(); // { id, name, email, roles } or null for a signed-out visitor
canWrite(); // hide editing controls from read-only users
row._owner === ownerTag("scores"); // own-rows datasets: is this the visitor's row?Realtime
import { useChannel } from "appable";
// Throwaway, fast state between everyone in the channel: cursors, games, presence
const { send, members } = useChannel<Msg, { name: string }>("room", (msg) => { /* … */ }, { presence: { name } });AI inside the app
On Pro and up, an app's owner can switch on AI for it in the app's AI tab, choose the model and set a monthly credit limit. Calls are billed to the owner; the app's code can't choose the model or raise the limits, and signed-out visitors can only use it if the owner allows.
import { ai } from "appable";
if (ai.enabled()) {
const summary = await ai.complete(`Summarise in one line: ${note}`, { maxTokens: 120 });
const tags = await ai.json<{ category: string }>(`Classify as JSON {"category": string}: ${text}`);
}
AI models and keys
- Every plan includes monthly AI credits on Makesso's key. One credit is one US cent of AI use; dearer models use credits faster, and Settings shows how much faster.
- Free uses budget models (up to DeepSeek V4 Flash). Pro and up add premium models such as Claude, GPT and Gemini.
- Bring your own key (OpenRouter, OpenAI, Anthropic or any compatible endpoint) on any plan: any model, no credit limit, and your provider's data terms. Keys are encrypted and never given to the agent.
- On Makesso's key, requests only go to providers that don't store prompts or train on them.
Claude, ChatGPT and Cursor (MCP)
On Pro and up, the AI assistant you already use can build and change your apps through Makesso's MCP server, with the same tools and guide as Makesso's own agent.
- Connect: in Makesso, open Settings → AI assistants and copy the address. In Claude: Settings → Connectors → Add custom connector. In ChatGPT: Settings → Connectors (developer mode). In Claude Code:
claude mcp add --transport http makesso <address>. Then sign in to Makesso and choose what it may do. - Its AI, not your credits: the assistant does the thinking with your own subscription; Makesso stores, builds, runs and secures the app. It can create apps, edit code, add datasets and assets, install packages, build, type-check, and open the app in a browser on our servers to see it and catch errors. Pair it with a browser tool (such as Playwright MCP in your own browser) and it can click through the app like a person would.
- You choose the access: seeing apps (code and data structure, no rows) is always included; building is on by default; reading staging data, reading real data, deleting what it created and using Makesso's own agent are each opt-in. Limit it to chosen apps if you like.
- Some things stay with you: an assistant can never publish to production, share an app, set up sign-in or data rules, delete apps or data people made, or change settings, keys and plans. Apps with staging are changed in staging only.
- Every change is a version: changes are saved as versions named after the assistant (e.g. “Via Claude: Add a chart”), so you can see and undo them. Settings shows each connection's recent activity, and Disconnect ends it at once.
Limits and plans
Plans set how many apps and datasets you have, storage, upload size, AI credits and which features are included; every limit is enforced by the server, whatever a request says. Moving to a smaller plan never deletes anything. See Pricing for the details, and Your data for what we store and where (Paris, in the EU).
The tool your team keeps asking for is one sentence away.
Start free. Describe it, watch it build, and share it with your team before lunch.
No credit card. Free plan forever.