Your AI builds the backend once.
The platform runs it.

Describe your app to Claude Code, Cursor or any MCP client. nostackai turns it into entities, Logic Blocks, agents and docs, and runs it serverless on AWS with no model in the request path.

Request Early Access Watch the tour

console.nostackai.com

Token-minimal runtime

90-tool MCP server

Events & automation

Any AI model, your keys

Custom code with Glyphs

Agent crews

Realtime WebSocket

Always-current docs

Multi-tenant SaaS

How it works

AI at design time. Plain code paths at run time.

Most AI builders keep a model in the loop for every change. nostackai uses your AI for the part that needs judgement, then gets it out of the way.

01 Design

Your AI describes the app

Over MCP it reads what the platform supports, then creates entities, Logic Blocks, events, connectors, schedules and flags. Each call is a short JSON config.

02 Store

The config is the app

Every asset is versioned and diffable. A change is a merge of a few fields, so the AI never re-reads or regenerates a codebase.

03 Run

Requests run without a model

CRUD, search, access checks, events and schedules are deterministic. Tokens are spent only in the AI steps you add, with your own keys.

See where the tokens go

MCP-native

Ninety tools. One connection.

Every org gets a hosted MCP server. Point your AI client at it and the AI can build and change every part of the backend, then test what it built. It works with the AI subscription you already pay for.

Covers entities, Logic Blocks, Glyphs, crews, events, schedules, feature flags, connectors, workspaces, access policies and email templates
Grounded by get_platform_capabilities and a live API reference, so the AI does not guess at what exists
Build in dev, verify with test_logicblock and invoke_glyph, then publish to production yourself
Every call is checked against the caller's access policy and written to an audit log

See all 90 tools

Changing a live backend · 3 calls

01describe_logicblockcheckoutread

02update_logicblockadd tax step · 1 field mergedsaved

03test_logicblocksample cart · 200 OKpassed

API Studio · entities / order

Entities

order

product

cart

customer

Access

shopper

store_admin

order

per workspace

iduuidprimary

customerlookupindexed

totalnumberformula

card_tokenstringencrypted

POST/app/acme/create/orderauto

GET/app/acme/item/order/:idauto

LIST/app/acme/list/order?by=allauto

PATCH/app/acme/update/order/:idauto

DEL/app/acme/delete/order/:idauto

APIs from config

Define the data. The API exists.

Each entity gets create, get, list, update, delete and count endpoints, with search, filters, facets and pagination. A live OpenAPI 3.1 spec stays in step with every change.

IAM-style access policies with Allow and Deny, enforced on the server for every request
Field-level AES-256 encryption for secrets and personal data
Lookups, formulas, categories, unique and composite indexes
Public endpoints for contact forms and guest order lookups, with no login
Bulk CSV or JSON upload, and files served from a CDN

All data features

Events · order, ticket

beforeorder · creategate: total > 0 and stock availableveto

afterorder · createemail orderPlaced to the customersent

afterorder · createrun Logic Block reserve_stockdone

afterorder · updatestatus = shipped → Slack #fulfilmentsent

afterticket · createstart crew triage_ticketrunning

Events & automation

Every write can start something.

Attach events to any entity. When a record is created or updated, nostackai runs what you chose, in the background or as a gate before the write is saved.

Before events check a write and can reject it; after events react to it
Send templated email, Slack or SMS; call a webhook or any connector; write to another entity or to S3; run a Logic Block; start an agent crew
Entry conditions decide when an event runs, and field mapping fills the destination from the record
Every delivery is logged and traced, so you can see what ran and why

Events & automation

AI where it earns its keep

Put a model in the path only where judgement is needed.

Logic Blocks are deterministic pipelines. Add an AI step, a crew or a human approval exactly where you need one. Each AI step gets only the fields you map, answers in the shape you ask for, and runs under the token caps you set.

ai_call

Typed AI steps

Classify, extract, summarize, decide, translate, moderate and more. Pick the model per step and ask for a score, a category, a yes/no or JSON, so the answer stays small and checkable.

document_extract

Read files and media

Pull text from documents, images and audio, and transcribe speech, inside the same Logic Block.

crews

Multi-agent crews

Agents run as a graph. Agents without unmet dependencies run in parallel, each with its own model and memory.

human gate

People approve the risky parts

A crew pauses for a person to approve, answer or edit, from the console or your own app.

agent tools

Agents act on your real data

Read and write entities, call connectors, run Glyphs, search the web, or hand off to another crew. Access policy applies to every call.

limits

Caps on every run

A token cap per step and per crew run, turn limits, and guardrails that stop off-topic input before the model is called. Tokens and cost show per run and per workspace.

AI agents

glyph · apply_loyalty_discount

# glyph: apply_loyalty_discount   (Python 3.12)
def handler(request, ctx):
    order = ctx.app_db.get_entity('order', request['id'])
    past = ctx.app_db.list_entities('order',
        filters=[{'field': 'customer', 'op': 'eq',
                  'value': order['customer']}])
    rate = 0.1 if len(past['items']) >= 5 else 0
    return {'discount': round(order['total'] * rate, 2)}

Glyphs

Write code only where config stops.

A Glyph is a small function in Python 3.12 or Node 22 that runs sandboxed next to your data. Use it as a Logic Block step, an agent tool, a scheduled job or its own endpoint.

ctx.app_db, ctx.http, ctx.connector, ctx.ses, queues and events, plus a curated standard library
Drafts, published versions and full restorable history
Code is hash-checked before every run, and secrets are redacted from logs
Large Glyphs run up to 14 minutes with 2 GB of memory on Pro

Custom code

Connectors

26 connectors. Each workspace brings its own credentials.

Adopt a connector for your org, and each customer workspace enters its own keys. Call it from a Logic Block, an event, a schedule, an agent or one API call. Inbound webhooks land straight in your entities.

Payments

StripePaddleDodo PaymentsPayPal

Checkout for one-time and subscription products, cancellations, and signed webhooks that confirm payment back into your entities.

Messaging

EmailSlackTwilio SMS

Notify from any automation, Logic Block, schedule or agent.

CRM

Salesforce

Create, update and upsert any Salesforce object.

Coding agents

ClaudeClaude CodeCodexCopilotJulesMuse Code

Hand a task to a coding agent from a crew or a Logic Block.

Dev tools

GitHubScreenshot Service

Issues, pull requests and page captures as workflow steps.

SerperTavily

Web search results your agents can reason over.

Commerce

EasyPostTaxJarGoogle Maps

Shipping labels and rates, sales tax, address lookup.

Cloud & storage

AWSAmazon S3

Call AWS services and write to your own buckets.

Scheduling

Calendly

Bookings and events in your data.

Automation

Zapier

Reach 7,000+ apps through Zapier.

Any other API

Webhook

Connect anything not listed: any HTTPS endpoint with no auth, a bearer token, basic auth, a custom header or OAuth2 client credentials, and the payload you map.

SaaS plumbing

The parts AI builders leave for later, already built.

Everything a B2B app needs once the first customer signs, without writing it twice.

workspaces

Multi-tenant from day one

Single, hybrid or multi-tenant apps. Users join or create workspaces, accept invites, and get workspace admins.

sso

Workspace SSO

Each customer workspace signs its users in with Okta, Google or a password. Domain checks keep the wrong company out.

settings

Per-workspace settings

General values and encrypted secrets per workspace, email templates and branding, read by your logic at run time.

schedules

Schedules

Run a Logic Block, Glyph, connector or crew once, on an interval, or on a cron, in any timezone.

feature flags

Feature flags

Targeting rules, percentage rollouts, scheduled changes and per-workspace overrides, with JavaScript, React, Vue and Angular clients.

payments

Payments

Stripe, Paddle, Dodo Payments and PayPal for one-time and subscription checkout, confirmed by signed webhooks.

Multi-tenant SaaS

Realtime

A WebSocket endpoint, ready on day one.

Every app gets a secure wss:// endpoint. Stream AI answers token by token, show a crew working step by step, or push one update to everyone watching, with no socket server to run.

Sign in with the user's own token; channels you name are scoped to their org and workspace on the server
Run any Logic Block over the socket and stream its AI tokens and progress
Stream every turn of a crew run, and follow a live activity feed of all runs
Set notifyall in a Logic Block to push its result to everyone on the channel

Realtime use cases

app.js · realtime

const ws = new WebSocket(`wss://<your app's realtime endpoint>?token=${token}`);

ws.onopen = () => ws.send(JSON.stringify({
  action:  'customapi_run',        // run a Logic Block, stream it
  channel: 'order-board',          // you name it; scoped to your workspace
  message: { apiName: 'mark_shipped', input: { id: '4821' } },
}));

ws.onmessage = (e) => {
  const { type, data } = JSON.parse(e.data);
  // customapi_result  → your own result
  // customapi_message → pushed to everyone on the channel (notifyall)
  // turn_event        → each step of a crew run
};

API Reference in the Architecture Studio — 278 operations, generated live from the current config.

Docs that never go stale

API and architecture docs, always current.

Documentation is generated from your configuration every time you open it. Change an entity or a Logic Block and the docs already show it.

A live OpenAPI 3.1 spec to import into Swagger, Postman or any API tool
Data model diagrams, Logic Block and event flows, an integration map and the infrastructure diagram
Step-by-step walkthroughs of how each request travels through the system
Descriptions travel with each asset to production, and the whole thing exports to PDF, on every plan

Live documentation

Run it with confidence

See it, ship it, roll it back.

The tools you need once real customers depend on the app.

Dev → production

Publish from dev, compare versions by content, activate and roll back.

Observability

Call log, error rate, p50 and p95 latency, agent cost and guardrail hits, with traced and redacted delivery history.

Usage per workspace

API calls, records written, Logic Block runs, and AI input tokens, output tokens and cost for each customer workspace.

Isolated by design

Every org's and workspace's data sits in its own partitions, checked on the server for every request. Enterprise gets a dedicated stack.

Built on nostackai

Two real builds, start to finish.

Storefront products served by the generated API

Use case

An online store with PayPal checkout

Products, carts, a checkout Glyph and payment webhooks, built from one import file.

Use case

An AI software team on GitHub

Stories become tasks, a coding agent opens the pull request, a reviewer agent comments.

Compared honestly

Good tools, different jobs.

Supabase is a great database. AI app builders are great at UI. nostackai is the backend your AI builds once and does not have to keep rebuilding.

Capability	nostackai	Supabase	Xano	AI app builders Emergent, Lovable, Bolt	Workflow tools n8n, Zapier
Who writes the backend	✓Your AI, as config, over MCP	!You: SQL, edge functions	!You: visual or XanoScript	✓The builder's AI, as code	!You: visual flows
What a change costs	✓A small config merge	!Your time	!Your time	✕A new prompt over the codebase, billed in credits	!Your time
AI tokens in each production request	✓None, unless you add an AI step	✓None	✓None	!Depends on the generated code	!Per AI node
AI keys and billing	✓Your keys on every plan, per workspace, no markup	!Bring your own	!Bring your own	✕Platform credits	✓Bring your own
MCP server for your AI client	✓90 design-time tools	✓Official server	✓Developer MCP	✕Built-in agent instead	!MCP nodes
Multi-tenant SaaS: workspaces, workspace SSO, per-workspace settings	✓Built in	!Build it with RLS	!Build it	!Whatever was generated	✕

Full comparison, and when to pick something else

Ready when you are

Describe it once. Run it forever.

Connect your AI client, build your backend, ship to production.

Request Early Access Connect an AI client

Your AI builds the backend once.The platform runs it.

AI at design time. Plain code paths at run time.

Your AI describes the app

The config is the app

Requests run without a model

Ninety tools. One connection.

Define the data. The API exists.

Every write can start something.

Put a model in the path only where judgement is needed.

Typed AI steps

Read files and media

Multi-agent crews

People approve the risky parts

Agents act on your real data

Caps on every run

Write code only where config stops.

26 connectors. Each workspace brings its own credentials.

The parts AI builders leave for later, already built.

Multi-tenant from day one

Workspace SSO

Per-workspace settings

Schedules

Feature flags

Payments

A WebSocket endpoint, ready on day one.

API and architecture docs, always current.

See it, ship it, roll it back.

Dev → production

Observability

Usage per workspace

Isolated by design

Two real builds, start to finish.

An online store with PayPal checkout

An AI software team on GitHub

Good tools, different jobs.

Describe it once. Run it forever.

Your AI builds the backend once.
The platform runs it.