Your data is isolated by the platform, not by luck.
AI writes the apps. It does not write the rules that keep your data safe. Those live underneath every app, and they apply to every request, whatever the generated code does.
The AI writes your access rules.
Many app builders give generated apps a shared database and ask the model to write row-level security policies. When a policy is missing or wrong, which is easy to miss, anyone with the app's public key can read the table.
-- forgot one table select * from customers; → 12,408 rows
The platform decides what each request can see.
Every request gets its own sandbox containing only the data that person may use. A table they can't access is not hidden by a filter; it's not there at all. Why we built a secure AI app builder this way.
select * from customers; → Table customers does not exist
Defence in depth, from query to agent.
Per-request data sandboxes
Each query runs in a database instance that can only see the datasets that person may use, read-only where they may only read. File access, extensions and settings are locked before any query runs.
Private data per person
"Each user sees only their own rows" is enforced with a separate store per person, so it can't be undone by a missing filter.
A sandboxed agent
The AI works in an isolated environment that sees only the app it's building. It has no network apart from the Makesso API and the package registry, and it never holds your API keys.
Sharing that never over-shares
Sharing an app shares the app, not the rest of your data. An app can never do more with your data than its owner could, even when someone with more access opens it.
Apps in an isolated origin
Generated apps run sandboxed, away from your Makesso session. Access is checked on every request, and revoking a share takes effect immediately, even for open live connections.
Keys and accounts
API keys and secrets are encrypted at rest. Sign-in uses Google with PKCE; app passwords use Argon2id; sign-in links are single-use; and attempts are rate-limited.
Outside AI assistants on a short leash
When you connect Claude, ChatGPT or Cursor, it signs in with OAuth and PKCE and gets only what you tick: reading data, deleting what it created and spending credits are each opt-in, and you can limit it to chosen apps. Every call is checked against your own access, so it can never do more than you could. Publishing, sharing, sign-in and data rules are not available to it at all, and an assistant that may read data can't change apps open to the public without staging, so text planted in your data can't steer it into leaking rows. Tokens are short-lived and stored only as hashes; a stolen renewal token ends the connection. Apps it opens to check its work run in a sandboxed browser with no internet access, kept up to date with security patches every week.
We attack it ourselves, on every change.
An automated suite signs in as an outsider and tries every endpoint against someone else's apps, datasets, teams, settings and files. Another tries to escape the query sandbox, from reading other datasets' files to rewriting history. Both run before every release.
What we don't promise
Good security includes being clear about where the line is.
- An app's builder controls its code. What a visitor enters passes through code its builder wrote. Per-user data protects users of an app from each other, not from the app. Use apps from people you trust with that data.
- The agent works with your access. Instructions hidden in a file it reads could lead it to copy data you can see into the app you're building. Review what it builds before sharing an app widely.
- Packages come from npm. Libraries the agent installs run in its sandbox and become part of your app's code.
Found a vulnerability? Email [email protected].
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.