● SaaS.Studio
Build SaaS for humans and agents.
One definition — entities and functions — becomes a human UI and api · cli · mcp · sdk. Plus a Zapier app, your marketing site, and the operating business behind it.
$ npx create-saas-app
import { App, ai } from 'saaskit'
export default App({
name: 'ledger',
entities: {
Invoice: { amount: 'number', status: 'open | paid | void', dueAt: 'date' },
Customer: { name: 'text', email: 'email' },
},
functions: {
markPaid: (i: Invoice) => ({ ...i, status: 'paid' as const }),
remind: ai('Draft a friendly overdue reminder', { input: Invoice }),
},
})
// → exposes human UI + api · cli · mcp · sdk automatically● The old way
The old way is too slow.
Three ways SaaS gets built today — and the seam each one leaves on the table.
UI-first SaaS is slow.
Months of CRUD, auth, and screens before a single customer — most of it scaffolding a compiler should emit for free. SaaS.Studio emits it.
No-code stalls at real logic.
Fine for a form, hopeless at scale, workflows, or anything an agent needs to call programmatically. Real logic deserves real code — declared at the right altitude.
Agents can't click buttons.
A screen-only app is invisible to the buyers that now do the work. The next customer arrives over an API — and your SaaS has to be there.
● How it works
Declare it once.Ship the whole business.
Define your SaaS as entities (the data) and functions (the logic). SaaS.Studio compiles that single definition into every surface and every output a running business needs — no glue, no separate clients to maintain.
entities: { ... },
functions: { ... },
})
Two declarations. PascalCase entities, camelCase functions. That's the whole authoring surface.
Human UI
Forms, tables, detail views, auth — generated.
Agent surfaces
api · cli · mcp · sdk — all four, always on.
Integrations
A Zapier app for every SaaS + native/direct.
Marketing site
Landing, blog, competitor pages — agent-readable.
Sales handoff
Wired into Startups.Studio's sales-builder.
and the running business behind it — see below.
● Every surface
One definition.Every surface.
Humans get a UI. Agents get four protocols. All five are generated from the same definition, and all five are always on — there is no per-SaaS toggle.
Forms, tables, detail views — generated for humans to use directly.
Typed REST + schema. The default for any caller, human or machine.
Scriptable from the terminal and CI — installed by URL, never lagging behind.
Model Context Protocol — your app, callable by agents. The agent-native edge.
Typed client for the humans still building UIs, importable straight from the URL.
one definition → human ui + api · cli · mcp · sdk
● Integrations
Reachable by every other tool, automatically.
The same entities and functions that power your UI and surfaces also power the integration surface — no separate connector code to write, maintain, or keep in sync.
A Zapier app for every SaaS.
Every SaaS built on SaaS.Studio auto-generates a Zapier app — your entities become triggers and searches, your functions become actions. Reachable by every Zapier user from the day you ship.
Native and direct, via id.org.ai.
When you need a first-party integration, id.org.ai is the OAuth redirect domain — purpose-built to be generic enough for any tenant and credible enough that end users trust the callback. The identity layer your integrations share.
zapier app + native/direct via id.org.ai — one definition, all targets.
● Your marketing site, too
The site that sells your SaaS — also generated.
Every SaaS gets a marketing site on day one: landing, blog, competitor pages — wired into Startups.Studio's sales-builder so top-of-funnel flows through to revenue.
Landing page
Hero, surfaces, value — generated from your SaaS definition.
Blog
Content surface for SEO + agent-engine-optimisation.
vs-competitor pages
One page per competitor — agent-citable comparisons.
Agent-readable
llms.txt + markdown at the same URL. Built-in.
Agent-readable, end to end. Every page on the SaaS's marketing site is served as HTML for humans and markdown for agents — same URL, two formats — with /llms.txt and /llms-full.txt at the root. The LLMs your tenants want to be cited by can actually read the site.
stand-in panel · @mdxui/dashboard-panels swap-in once published
● Run by agents
Your SaaS is more than a product.It's a business that runs.
Every SaaS on SaaS.Studio ships with its full operating org — Marketing, Sales, Customer Success, Support, Finance, Compliance, Operations — running as Business-as-Code with agents. Chain-specific roles layer on top based on who your customers are.
Tier 1 · Universal — default-on for every SaaS
Marketing
Content, demand gen, SEO/AEO, blog, comparison pages.
Sales
Lead qualification, demos, close — typed pipeline, audited touches.
Customer Success
Onboarding, activation, expansion, renewals — Goals/KPIs the agents pursue continuously.
Support
Help, troubleshooting, exception handling — every step logged as an Event for audit.
Finance
Billing, dunning, recovery, payouts, FP&A — typed flows end to end.
Compliance
Audit evidence, policy enforcement, regulatory reporting — produced as work happens.
Operations
Identity scoping, Oversight runtime, incident response, internal coordination.
Tier 2 · Chain-specific — auto-suggested by Buyer Chain
Account Management
Named accounts, QBRs, expansion.
Trust & Safety
Consumer protection, HITL escalation, abuse detection.
Marketplace Operations
Escrow, dispute arbitration, matching, anti-collusion.
Procurement Liaison
Principal verification, authority-scope enforcement.
Developer Relations
API docs-as-surface, error explanation, change comms.
Each process declares its Oversight posture — autonomous, review-required, or human-in-the-loop — as a first-class attribute, not a hedge.
Roles pursue typed Goals against measured KPIs. The agents know what good looks like and can be steered by changing the number.
Every decision and action is an immutable, append-only Event. The business's past is replayable — and auditable — by construction.
flagship → headless.ly runs as the proof point — operating model and product mode in one tenant.
● Compliance
Compliance comes with the platform.
Compliance-by-construction at both layers — the infrastructure and the way the business is run. Your audit timeline collapses from months to weeks because most of the controls are already in place, and the rest are audit-trailed by construction.
The platform owns the controls.
- Identity, tenancy isolation, audited impersonation
- Encryption, backup, change-management
- Roughly 60–70% of typical SOC2 controls — inherited.
Run the business as code; the audit trail is intrinsic.
- Every process is typed; every decision is a logged Event
- Every action declares its Oversight posture as a first-class attribute
- Covers most of the remaining process / governance controls.
Inherited isn't the same as certified. Tenants still run their own audit — but with most controls already in place and audit-trailed at both layers, the timeline collapses from 6–12 months to weeks. We'll say “certified” when the platform's own Type II report is in hand; until then, “compliance-by-construction” and “SOC2-ready” are the honest words.
Self-hosting saaskit gets you the patterns — identity hooks, typed processes, audit-trailed Events — but not the inherited platform controls. Compliance-by-construction is a managed-platform benefit; the OSS framework is the framework.
● Headless SaaS
Built for agents too — not just humans.
Most SaaS is invisible to the agents that now do the work. A Headless SaaS isn't — it's defined as entities and functions and exposed on every surface an agent calls: api · cli · mcp · sdk — with a UI only where a human still needs one.
Headless is a modeof SaaS.Studio, not the whole product (per ADR 0001) — but it's the mode the agentic economy needs first, and the one Phase 1 ships fastest.
The dogfooding proof point — a Headless SaaS built on the same multi-tenant infra SaaS.Studio offers everyone else. Not a competitor; a flagship.
- Entities + functions exposed as api · cli · mcp · sdk
- Generated marketing site, served agent-readable
- Operating Business runs on the same substrate
● vs the app generators
They generate apps.We generate the whole running business.
bolt.new, Replit, Lovable, v0 — all good at generating apps. But an app is one of seven outputs a running SaaS needs. The other six are where the work actually lives.
bolt.new
read the comparison
Replit
read the comparison
Lovable
read the comparison
v0
read the comparison
They start at the code level — a screen, a route, a component. We start one level up — entities and functions — and the whole stack follows. There is no low-level plumbing to maintain because there is no low-level plumbing.
Their generated apps still need a human (or another tool) to run marketing, sales, customer success, support, finance, compliance, operations. Our SaaS includes the operating business itself — typed Business-as-Code processes with Oversight and audit trail.
Their generated apps inherit none of your compliance posture. SaaS.Studio inherits SOC2-ready controls at both the infrastructure and the business-operations layers — audit timeline collapses from months to weeks.
comparison pages land in v2 — anchors reserved here for /vs/<competitor>
● Open source
saaskit is the framework.SaaS.Studio is the managed platform.
Same shape as Next.js → Vercel. The framework is free, open, and self-hostable. The managed platform takes the framework all the way to a running business — built on platform.do.
The framework you write a SaaS in.
npx create-saas-app scaffolds a project today. Published on npm at v0.2.15; MIT. Self-hostable — same authoring surface as the managed platform.
The whole running business, hosted.
The same authoring surface, plus everything around it: the operating business, the integrations, the marketing site, the sales handoff, and compliance-by-construction at both layers. Built on platform.do.
Self-host caveat. Running saaskit yourself gets you the patterns — typed processes, identity hooks, audit-trailed Events — but not the inherited platform compliance controls. The compliance-by-construction story is a managed-platform benefit; the OSS framework is the framework.
● Ecosystem
Standalone — and part of Startups.Studio.
SaaS.Studio works on its own for any SaaS builder. It also slots into Startups.Studio — vibe-code a startup at Startups.New, and if it turns out to be a SaaS, this is where the SaaS side gets built and run.
Vibe-code a new startup — the upstream of the ecosystem.
If it's a SaaS, build and run the SaaS side here.
Wires the generated marketing site through to revenue.
startups.new → saas.studio → sales-builder