Why build here
Your app, in front of the businesses already running their day on hoje.ai.
hoje.ai is a production platform people sign into. An app here lives inside one person's space, beside the tools she already uses — and she agrees to exactly what the app asks for before anything installs.
This is the business case, measured 2026-09-19. The road below it is the same honest walk this page has always carried, with its stopping point in view.
Who you reach
The people already on the platform — not a customer list you bring with you.
| Line | State | Licence | Evidence |
|---|---|---|---|
| hoje.ai serves real people in production today. | live | a | https://hoje.ai/ answered 200 on 2026-09-19 |
| A real business runs its whole product here, at its own domain. | live | a | https://agenda.luveiga.com/ answered 200 on 2026-09-19 |
No publisher's app is on the platform yet. The road below is where that changes, and its rule names the day it was true.
What the catalog gives you
Distribution is the shelf: what a person opens when she looks for an app like yours.
| Line | State | Licence | Evidence |
|---|---|---|---|
| The apps a person already has are drawn in her portal's nav, in her own language. | live | b | src/uis/portal/registry.tsx |
| A store she can browse — every published app with its ask in plain words, install in one step, uninstall just as easily. | not yet | — | Moves when something implements the browse and the install act behind it. The store is specified to the row — the disclosure, the one-step install, the uninstall — and nothing serves it yet. |
What shipping earns you
The honest version of the flywheel — what is real today, and what the first publishers set.
| Line | State | Licence | Evidence |
|---|---|---|---|
| Your app's ask — which parts of a person's space it touches, with which verbs — is written before anything installs, and she agrees to it, or she doesn't. | live | c | src/protocols/app-data/manifest.ts. No deployed worker runs it yet; it is a published contract you can read and build against today. |
| Every app a partner ships makes the platform's multi-app story truer and every tenant harder to leave. | being built | — | The platform side runs in production; the publishing side has never carried an outside app. Moves when the first manifest from outside this repository is published. |
| A developer program — registration, official listing, the terms a shipped app is carried on. | not yet | — | Moves when something implements either half of registering or listing. Nothing does. |
From an idea to the road
The path does not end here, and it does not start a second copy of itself. The road, the contract and the state words are this page's own, below this section.
- The road — the six-step walk from nothing to an installed app, with the rule drawn where it stops.
- The contract — the manifest, printed in full and readable with nothing installed.
- Running today — the narrow facts, each saying the small true thing.
- The three words — what live, being built and not yet mean on this page.
Lede
An app on hoje.ai is a frontend bundle and a manifest.
The manifest declares, before anything installs, exactly which parts of a person's space your app touches and with which verbs. They read that ask and agree to it, or they don't.
You cannot ship one yet.
Every app running on hoje.ai today is one we built — its code is in our build. Nothing here mounts code from a publisher's own space, and there is nowhere to register as a developer.
This page is the route and the point where it stops. Measured 2026-09-07.
Running today
The narrow facts. Each says the small true thing; the larger promise built on it is a step in the road below and carries its own state there.
| Line | State | Licence | Evidence |
|---|---|---|---|
| hoje.ai is in production, and people sign in to it. | live | a | https://hoje.ai/ answered 200 on 2026-09-07 |
| A business runs its own product on this platform, on its own domain. | live | a | https://agenda.luveiga.com/ answered 200 on 2026-09-07 |
| The app manifest is a published contract, not a proposal — a closed grammar with two reference manifests written against it. No deployed worker runs it yet; it is code you can read and build against today. | live | c | src/protocols/app-data/manifest.ts, with src/protocols/agenda/manifest.ts and src/uis/note/manifest.ts written against it |
| Every deployable here is one entry in one manifest. A push to the main branch ships it to staging; production is a deliberate promote of a build that already passed. | live | a | https://hoje.ai/ and https://agenda.luveiga.com/ are what it promoted; src/workers/deployables.ts is the manifest |
The last line is about our pipeline rather than yours, and it is on the page on purpose. "Who is on the other end of this, and do they know how to ship?" is the question a developer evaluating a platform actually asks, and a feature list never answers it.
The road
Six steps from nothing to an app someone on hoje.ai has installed, in the order you would walk them. One rule is drawn across the road at the point it stops.
| # | Step | State | Licence | Evidence |
|---|---|---|---|---|
| 1 | Read the contract. What an app declares about itself: its name, its kind, its entry, its version, its publisher, the access it asks for, and one line in your own voice. | live | c | src/protocols/app-data/manifest.ts. No deployed worker runs it yet; it is code to read and build against, and the whole of it is printed below. |
| — | The road stops here — 2026-09-07 | — | — | — |
| 2 | Build a frontend against a person's space. Your bundle mounts inside their shell, confined to the region your ask named, addressing only keys relative to it. | not yet | — | Moves when something mounts a bundle it did not itself build and hands it the interface its ask named. Nothing does that today. |
| 3 | Publish your manifest into your own space, at one immutable address per version. | not yet | — | The addresses and the rule that classifies the write are real code — src/protocols/app-data/addresses.ts. Moves when that runs inside something deployed; today it is reachable only from a test, and no publisher outside our own repository has ever written one. |
| 4 | Someone browses what you published, sees the exact access you asked for before anything installs, and installs in one step. | not yet | — | Moves when there is a place to browse published apps and an install act behind it. Neither is built. |
| 5 | Your app hands off to the next one, because what it wrote sits in a shared structure the next app can read. | not yet | — | The ask grammar already names shared structures. Moves when their layout is fixed, so two apps naming the same structure agree on what is in it. |
| 6 | Register as a developer and list in the official catalog. | not yet | — | The policy is settled: publishing from your own space is self-serve, official listing is vetted. Moves when something implements either half. Nothing does. |
Below the rule the steps keep their numbers, their words and their evidence. They lose only their promise. They are still the real route, which is what you came for.
The contract
The one thing on this page you can act on today, printed rather than linked — so it is readable with nothing installed, no account, and no access to our code.
A manifest is a data record, not a config file we host. It carries name, kind, entry, version, publisher, access, and an optional pitch — one line in your own voice, shown to the person at the moment they decide to install.
Two kinds. vendored — the platform build carries your code, and entry is a registry id. bundle — your code loads from your own space and mounts sandboxed, and entry is an address. Same record, same install, and only the mount mechanics differ.
One kind is reserved, and it is the one you will guess. declarative parses and is then refused — it is never stored. It is held for a second wave.
Three verbs, and no more: read, receive, observe. Your ask enumerates regions and verbs, and it is exactly the scope of the interface the platform injects when your app mounts. It is not a statement of intent about what you will do; it is the thing itself.
Two regions. private is your app's own region of that person's space. shared names a shared structure — the seam that lets their next app pick up where yours left off.
Versions are immutable. A new version is a new address. An overwrite is classified a defect and is not applied.
One address shape: orgs/<org>/apps/<app>/manifest/<version>.
The three words
Three state words appear on this page, and only three.
- live — running in production today.
- being built — the pieces are running; the thing that joins them is not finished.
- not yet — a sentence. Nothing that does this is finished.
A word is only as good as what licenses it, so each is read one of three ways: a — an address answers in production. b — the code behind it is bundled in something deployed and covered by a test that actually runs. c — the code is at a named path in our public, versioned repository and covered by a test that actually runs. c licenses only that a published artifact exists and says what this page says it says — never that anything happens with it, which is why every c line above carries, in your view, the note that no deployed worker runs it.