Appmint - AI That Builds & Runs Your Entire Business

AppMint is a small set of pieces that share one backend. Knowing which piece does what makes the rest of the docs easy to navigate.

The pieces

                   +-------------------------+
                   |      Your front end     |
                   |  Next.js / Flutter /    |
                   |  React Native / Web     |
                   +-----------+-------------+
                               |
                               | REST + WS + SSE
                               v
+--------------+  +-----------------------------+  +---------------+
| chat-client  |->|         AppEngine           |<-|  Appmint Studio  |
|  (widget)    |  | NestJS multi-tenant backend |  | admin web app |
+--------------+  |                             |  | + Chrome ext  |
                  | auth | data | storefront    |  +---------------+
                  | crm | chat | voice | phone  |
                  | broadcast | finance | bank  |
                  | automation | ai | sites     |
                  +--------------+--------------+
                                 |
                                 | (deploys, manages)
                                 v
   +-----------------+   +---------------+   +-----------------+
   |  Vibe Studio    |-->|  agent-zero   |-->|    SpinForge    |
   |  (AI build UI)  |   |  (AI agent)   |   |  (deploy host)  |
   +-----------------+   +---------------+   +-----------------+

                 Mobile SDKs (Flutter) -> AppEngine

Everything connects to AppEngine. Every other piece either consumes the API or is deployed/managed by it.

What each piece does

AppEngine

The multi-tenant backend. NestJS modular monolith on MongoDB, with Redis for queues and WebSocket fan-out. One AppEngine instance serves every tenant — the orgid header scopes data, and JwtAuthGuard resolves the principal on every request.

Domains covered, at a glance:

Auth & users — staff (User) and end-buyer (Customer) principals, OAuth, magic links, API keys, 2FA, RBAC.
Data — BaseModel\<T\> over ~150 built-in collections plus runtime-defined custom ones, generic CRUD at /data/* and /repository/*.
Commerce — products, cart, orders, gift cards, inventory, shipping, tax, returns, rentals, subscriptions, Stripe + PayPal.
CRM — contacts, leads, audiences, marketing, ads, campaigns, events, tickets, comms inbox, activities.
Realtime — chat, voice (OpenAI Realtime), phone (Twilio), IVR.
Broadcast — email, SMS, WhatsApp, push.
Finance & banking — payouts, wallet, ACH/Wire/RTP, cards, KYC/KYB, lending, savings, merchant checkout.
Automation — flow builder, rules engine, IVR orchestration, AI-generated workflows.
AI — agent framework over Claude, function calling, SSE streaming, doc processing.
Sites — CMS-backed sites, domains, deployment to Kubernetes.

See the AppEngine reference for the mental model and the auth domain pages for endpoint specifics.

Appmint Studio

The admin app your operators live in. Runs as a Next.js web app (and a Chrome extension) talking to AppEngine. Manages everything an org owns: contacts, products, pages, automations, broadcasts, banking config, settings.

You don't have to use Appmint Studio — every action it performs is also an API call. But for most operators it's the fastest path.

chat-client

A small embeddable widget that puts live chat on any page. Connects to ChatGateway over WebSocket, supports presence, queue routing, and the AI assistant. Drop a <script> tag and configure the org/site; no other infrastructure needed.

Vibe Studio + agent-zero

The AI build environment. Vibe Studio is the interactive surface where you describe what you want; agent-zero is the LLM-driven agent that plans, edits files, runs builds, and iterates. Together they generate code that targets AppEngine APIs.

SpinForge

The deployment target. When agent-zero finishes a build, SpinForge hosts it — provisions a container, wires up domains, plugs in the org's data. Sites and apps built with Vibe Studio run on SpinForge by default.

Mobile SDKs

Flutter apps live in appmint_go/appmint_mobile/ and similar packages. They use the same REST/WS surface as web clients — the SDK is a thin wrapper around http with token refresh, presence, and domain-specific helpers (chat, repository, communications, files).

How requests flow

A typical end-to-end call from a browser:

The user signs in through your front end. AppEngine returns a JWT (and refresh token).
The front end stores the JWT (cookie or secure storage) and includes it on subsequent requests.
Each request also carries orgid: <your-org-id>. This is non-negotiable — without it AppEngine returns 400.
JwtAuthGuard validates the token, attaches the principal, then @RequirePermissions / @Roles decorators on the route gate access.
The route handler reads/writes through RepositoryService, which scopes everything to the org.
The response wraps the payload in BaseModel\<T\> for any record reads.

For server-to-server traffic (build pipelines, internal services), swap the JWT for an x-api-key header. Same orgid requirement.

Where to go next

Architecture — deeper look at the AppEngine internals (modules, queues, Redis, K8s).
Multi-tenancy — orgid, principals, RBAC with worked curl examples.
Data model — BaseModel\<T\> field-by-field.
Concepts — if you skipped getting started, this is the mental model.

Platform overview