> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gavai.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Who this is for

> gavAI is a platform for building production SaaS apps with three entry points — a visual builder, an MCP server for AI agents, and a typed REST API. This page describes who each fits and what the platform handles for you.

export const FeatureTable = ({columns, rows, featuredRow, caption, variant}) => <div className={`gv-feature-table ${variant ? `gv-feature-table--${variant}` : ""}`}>
    <table>
      {caption && <caption className="gv-feature-table__caption">{caption}</caption>}
      <thead>
        <tr>
          {columns.map(col => <th key={col.key} scope="col">
              <span className="gv-feature-table__header">{col.label}</span>
            </th>)}
        </tr>
      </thead>
      <tbody>
        {rows.map((row, i) => {
  const rowClass = [i === featuredRow ? "gv-feature-table__row--featured" : "", row.chosen ? "gv-feature-table__row--chosen" : ""].filter(Boolean).join(" ");
  return <tr key={i} className={rowClass}>
              {columns.map(col => {
    const v = row[col.key];
    if (variant === "tradeoff" && Array.isArray(v)) {
      const pill = col.key === "pros" ? "gv-feature-table__pill--pro" : col.key === "cons" ? "gv-feature-table__pill--con" : "";
      return <td key={col.key}>
                      {v.map((item, j) => <span key={j} className={`gv-feature-table__pill ${pill}`}>{item}</span>)}
                    </td>;
    }
    return <td key={col.key}>{v}</td>;
  })}
            </tr>;
})}
      </tbody>
    </table>
  </div>;

export const Path = ({icon, title, href, children}) => <a className="gv-choose-path__card" href={href}>
    {icon && <span className="gv-choose-path__icon" aria-hidden="true">
        <Icon icon={icon} />
      </span>}
    <h4 className="gv-choose-path__title">{title}</h4>
    {children && <p className="gv-choose-path__body">{children}</p>}
    <svg className="gv-choose-path__arrow" viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
      <line x1="7" y1="17" x2="17" y2="7" />
      <polyline points="7 7 17 7 17 17" />
    </svg>
  </a>;

export const ChoosePath = ({eyebrow = "CHOOSE YOUR PATH", label, children}) => <section className="gv-choose-path">
    <div className="gv-choose-path__header">
      <Eyebrow label={eyebrow} />
      {label && <h3 className="gv-choose-path__label">{label}</h3>}
    </div>
    <div className="gv-choose-path__grid">{children}</div>
  </section>;

export const PageMeta = ({audience, readingTime, prereqs, level}) => {
  const items = [audience && ({
    key: "audience",
    label: "AUDIENCE",
    value: audience
  }), readingTime && ({
    key: "time",
    label: "READ",
    value: readingTime
  }), level && ({
    key: "level",
    label: "LEVEL",
    value: level
  }), prereqs && prereqs.length > 0 && ({
    key: "prereqs",
    label: "PREREQS",
    value: prereqs.join(" · ")
  })].filter(Boolean);
  if (items.length === 0) return null;
  return <div className="gv-page-meta" role="group" aria-label="Page metadata">
      {items.map(item => <div className="gv-page-meta__item" key={item.key}>
          <span className="gv-page-meta__label">{item.label}</span>
          <span className="gv-page-meta__value">{item.value}</span>
        </div>)}
    </div>;
};

export const BrandCard = ({eyebrow, title, href, icon, badge, cta, featured = false, horizontal = false, children}) => {
  const classes = ["gv-card", featured && "gv-card--featured", horizontal && "gv-card--horizontal"].filter(Boolean).join(" ");
  const inner = <>
      {icon && <span className="gv-card__icon" aria-hidden="true">
          <Icon icon={icon} />
        </span>}
      <div className="gv-card__main">
        {(eyebrow || badge) && <div className="gv-card__meta">
            {eyebrow && <Eyebrow label={eyebrow} tone="muted" />}
            {badge && <span className="gv-card__badge">{badge}</span>}
          </div>}
        <h3 className="gv-card__title">{title}</h3>
        {children && <div className="gv-card__body">{children}</div>}
        {cta && <span className="gv-card__cta">
            {cta}
            <svg className="gv-card__cta-arrow" viewBox="0 0 24 24" width="12" height="12" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
              <line x1="7" y1="17" x2="17" y2="7" />
              <polyline points="7 7 17 7 17 17" />
            </svg>
          </span>}
      </div>
    </>;
  return href ? <a className={classes} href={href}>
      {inner}
    </a> : <div className={classes}>{inner}</div>;
};

export const ArrowItem = ({children}) => <li className="gv-arrow-item">
    <span className="gv-arrow-item__arrow" aria-hidden="true">{"↳︎"}</span>
    <span className="gv-arrow-item__content">{children}</span>
  </li>;

export const ArrowList = ({children}) => <ul className="gv-arrow-list">{children}</ul>;

export const Eyebrow = ({label, tone = "default"}) => <div className={`gv-eyebrow gv-eyebrow--${tone}`}>
    <span className="gv-eyebrow__bar" aria-hidden="true" />
    <span className="gv-eyebrow__label">{label}</span>
  </div>;

<Eyebrow label="OVERVIEW" />

<PageMeta audience="Everyone" readingTime="5 min" />

gavAI has three entry points: a visual Builder, an MCP server for AI clients, and a typed REST API. The same app can be authored through any of them — same JSON page document, same per-workspace runtime, same isolation. This page describes who each entry point fits, what the platform handles for you, and what "production-grade" means in concrete terms.

## Three audiences

<FeatureTable
  columns={[
{ key: "who", label: "Who" },
{ key: "how", label: "How they build" },
{ key: "where", label: "Where to start" },
]}
  rows={[
{
  who: "Non-technical owners",
  how: "Drag blocks onto a canvas in the Builder, configure data and capabilities through forms, publish to a subdomain.",
  where: "[The Builder](/concepts/builder-ux)",
},
{
  who: "AI-assisted builders",
  how: "Connect an MCP-aware client (Claude Desktop, Cursor) to the gavAI MCP server. The agent composes pages and schema; you review the changes.",
  where: "[MCP overview](/mcp/overview)",
},
{
  who: "Developers",
  how: "Call the REST API directly, use the typed SDK, drive workflows from the CLI, or implement custom capabilities.",
  where: "[Quickstart](/quickstart)",
},
]}
/>

The three entry points are not separate products. A page composed in the Builder, a page generated by an MCP-driven agent, and a page POSTed as JSON all produce the same document in the same workspace. You can switch between them at any time, on any page.

## What "production-grade" means here

A common concern about no-code platforms and AI-generated apps is that they ship demos that fall over in production. The boundaries that toys skip, gavAI handles:

<ArrowList>
  <ArrowItem>**Per-workspace isolation.** Every workspace runs on its own isolated runtime with its own database boundary. Cross-tenant access is structurally impossible. See [Multi-tenant isolation](/concepts/multi-tenant) for the threat model.</ArrowItem>
  <ArrowItem>**Validated writes.** Every write goes through your schema. Invalid data is rejected at the boundary.</ArrowItem>
  <ArrowItem>**Scoped tokens.** API keys, OAuth sessions, and MCP credentials each carry the minimum scopes needed. See [Token scopes](/security/scopes).</ArrowItem>
  <ArrowItem>**Audited access.** Every operator action against your workspace is logged. The trail is available on request.</ArrowItem>
  <ArrowItem>**Encrypted secrets.** Provider keys (Stripe, AI providers, SMTP) are envelope-encrypted with a key you can rotate.</ArrowItem>
  <ArrowItem>**Retry-safe by default.** Webhook delivery, idempotency keys, and JSON Patch operations are designed so retries don't double-apply. See [Idempotency](/api-reference/idempotency).</ArrowItem>
  <ArrowItem>**No content training.** Workspace content is not used to train models. Where AI processing involves subprocessors, contracts include explicit no-train terms.</ArrowItem>
</ArrowList>

These are claims you can verify against the architecture, not aspirations.

## What's included without writing code

The full product surface is point-and-click in the Builder. You can ship an app that does all of the following without touching code:

<ArrowList>
  <ArrowItem>**Authentication** — email + password, social sign-in, and magic links for your end-users, with one isolated user pool per workspace.</ArrowItem>
  <ArrowItem>**Data storage** — tables and fields configured through forms; no SQL.</ArrowItem>
  <ArrowItem>**Payments** — Stripe-powered checkout, plans, and subscriptions. Funds flow to your own Stripe account.</ArrowItem>
  <ArrowItem>**Transactional email and SMS** — wire a form submit to a confirmation message through configuration.</ArrowItem>
  <ArrowItem>**File uploads** — signed URLs, public/private toggles, automatic expiry.</ArrowItem>
  <ArrowItem>**AI capabilities** — chat, summarization, classification, and agent flows available as block configurations.</ArrowItem>
  <ArrowItem>**Your own subdomain** — apps ship at `you.gavai.app` by default; bring your own domain when ready.</ArrowItem>
</ArrowList>

## Monetization

Payments are part of the platform, not an integration step:

<ArrowList>
  <ArrowItem>**Stripe Connect onboarding** — set up your Stripe account from the Builder. Money flows to you directly.</ArrowItem>
  <ArrowItem>**Plans and subscriptions** — define tiers (free, pro, enterprise) in the Builder; the platform handles checkout, webhooks, retries, dunning, and plan changes.</ArrowItem>
  <ArrowItem>**Per-session billing for agents** — an AI agent that performs work for an end-user can be charged for that work and settled at the end of the session. The platform handles auth, metering, and Stripe.</ArrowItem>
  <ArrowItem>**Marketplace splits** — if your product has sellers and buyers, payouts and platform fees route automatically.</ArrowItem>
</ArrowList>

## What's available if you write code

Every visual gesture in the Builder maps to a typed API call. Everything available without code is also available as code:

<ArrowList>
  <ArrowItem>**Typed SDK** — `@gavai/sdk` covers every resource with TypeScript types, auto-retry, default idempotency, and trace instrumentation. See [SDKs](/sdks/overview).</ArrowItem>
  <ArrowItem>**OpenAPI 3.1 spec** — every endpoint documented; generate clients for any language.</ArrowItem>
  <ArrowItem>**MCP servers** — one for the Builder, one for the public API. Connect from Claude Desktop, Cursor, or any MCP client. See [MCP](/mcp/overview).</ArrowItem>
  <ArrowItem>**CLI** — `@gavai/gavai-cli` for builds, publishes, key rotation, and log tailing. Use locally or in CI.</ArrowItem>
  <ArrowItem>**Custom capabilities** — implement a capability against a typed contract; the Builder picks it up, end-users invoke it, the runtime dispatches and validates.</ArrowItem>
  <ArrowItem>**Programmable everything** — pages are JSON; patches are RFC 6902 JSON Patch; schemas are Zod. The Builder is one client of this surface; you can build others.</ArrowItem>
</ArrowList>

## Where to go next

<ChoosePath label="Pick the entry point that fits today">
  <Path icon="wand-magic-sparkles" title="Build visually" href="/concepts/builder-ux">
    The Builder walkthrough — sign-in to published app in six steps.
  </Path>

  <Path icon="sparkles" title="Connect an AI agent" href="/mcp/overview">
    Two MCP servers, scoped credentials, and a typed tool surface.
  </Path>

  <Path icon="code" title="Write code" href="/quickstart">
    Test API key and first call in under five minutes.
  </Path>
</ChoosePath>

<Columns cols={2}>
  <BrandCard eyebrow="CONCEPTS" title="How gavAI works" href="/concepts/how-it-works" icon="map">
    Three parties (end-user / workspace owner / gavAI), request flow end-to-end, and the role-vs-vendor model.
  </BrandCard>

  <BrandCard eyebrow="ISOLATION" title="Multi-tenant isolation" href="/concepts/multi-tenant" icon="building">
    The boundaries that keep one workspace's data away from every other workspace.
  </BrandCard>
</Columns>