apps.axthe multi-tenant App interpreter

Write one Definition. Get every face.

A directory, a CRUD admin, a marketplace, a store — an App deserves to be DATA when it can be, and secure CODE when it must be. Zero per-face authoring, multi-tenant with zero per-tenant code.

{Definition, seed, theme}Data tier
4×1
Definition in, every surface out
pageagent markdownREST APIadmin
instances live 4 · mounted by hostname
per-tenant code 0
rebrand theme swap · pure data
curl apps.ax/
$ curl https://apps.ax/
# apps.ax — write one Definition, get every face
**apps.ax is the multi-tenant App interpreter.**

## Mount an App, in three steps
1. Pick an archetype
2. Mount it
3. Ship

## Machine surfaces
- docs:     https://apps.ax/docs
- llms.txt: https://apps.ax/llms.txt

The problem

Building an App means building it four times

A page for humans. A markdown face for agents. A REST API. An admin. Standing up an App today means hand-building and wiring all four — separately, each free to drift from the state it describes. Multi-tenant means doing it again per tenant. That is groundhog-day building: the same plumbing re-authored every time, nothing compounds, and every face is a place the truth can diverge.

The answer

We got tired of watching four faces drift out of sync

So we built the interpreter we wanted: ONE typed Definition — the nouns and verbs of your App — folds into a single read model, and every face is a projection of that SAME model. Never authored twice. One machine already mounts four distinct Apps as data, by hostname (apis.directory, apis.ax, api.lawyer, api.insure) with per-instance themes and zero per-tenant code — live, today.

Two tiers

Two tiers, one interpreter

Data tierlive

{Definition, seed, theme} → every face via one render pass. Zero per-face authoring, zero marginal cost — the free optimization, not the limit.

Code tierin progress

Custom verbs, custom logic, or custom components (npm, React), running securely in their own isolated Worker — first-class, never an escape hatch.

Three steps

Mount an App, in three steps

Step 01

Pick an archetype.

Directory, CRUD, Marketplace, or Ecommerce (a preset noun/verb set) — or write your own typed Definition.

Step 02

Mount it.

The interpreter renders every face by hostname from {Definition, seed, theme}, no build; swap the theme (pure data) to rebrand.

Step 03

Ship.

The page face, the agent face, the API face, and the admin face all fall out of one Definition. Climb the customization ladder — defaults → theme → override → custom — only if you need to.

In production

Live proof

One interpreter Worker mounts four distinct Apps as data, by hostname, zero per-tenant code:

01
apis.directory — the submit-able marketplace
live
02
apis.ax — the curated agent-first marketplace
live
03
api.lawyer — the legal surface
live
04
api.insure — the insurance surface
live

The stakes

What's at stake

Without apps.ax

  • The same four faces rebuilt per product
  • Side systems that drift from the state they describe
  • Multi-tenant sprawl of per-tenant code

With apps.ax

  • Every face is a projection of one Definition — never authored twice
  • Multi-tenant with zero per-tenant code
  • Rebrandable by swapping a theme row, not shipping code

Machine access

For agents

The machine contract lives at this same URL — curl https://apps.ax/ returns it as markdown. Also published: docs and llms.txt.

curl https://apps.ax/