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.