diff --git a/scripts/check-plain-coverage.mjs b/scripts/check-plain-coverage.mjs
index d6e7a6e..eb260d2 100644
--- a/scripts/check-plain-coverage.mjs
+++ b/scripts/check-plain-coverage.mjs
@@ -36,6 +36,8 @@ const MAIN_PAIRS = [
{ human: 'src/pages/for/mcp.astro', plain: 'src/pages/plain/mcp.astro' },
{ human: 'src/pages/plans.astro', plain: 'src/pages/plain/plans.astro' },
{ human: 'src/pages/for/skills.astro', plain: 'src/pages/plain/skills/index.astro' },
+ { human: 'src/pages/app-store.astro', plain: 'src/pages/plain/app-store.astro' },
+ { human: 'src/pages/publish.astro', plain: 'src/pages/plain/publish.astro' },
];
// Directory pair checked for strict 1:1 slug correspondence.
diff --git a/src/pages/app-store.astro b/src/pages/app-store.astro
index 568717d..b3e4fcc 100644
--- a/src/pages/app-store.astro
+++ b/src/pages/app-store.astro
@@ -164,44 +164,57 @@ try {
For builders
-
Ship an agent app.
It's just a manifest.
+
Ship an agent app.
By PR or in your browser.
+
+ Bring an app you already have. Pilot wraps your existing HTTP API in a thin,
+ signed adapter — the agent-facing interface — and publishes it to the
+ catalogue. Pick the path that fits how you work.
+
-
Manifest
-
Declare your app
+
No code
+
Publish in your browser
- An agent app is defined by a
manifest.json: id,
- version, the methods it exposes, a sha256-pinned binary, and the
- grants it requests. No Docker, no Kubernetes — the protocol handles
- distribution.
+ Describe your app once in the
publish wizard — id,
+ methods, backend URL, and any auth headers. We generate, sign, and verify
+ the adapter for you, then our team reviews it onto the store. No Go to
+ write, no git, no manifest by hand.
+
Publish your app →
-
Submit
-
One PR to publish
+
From the CLI
+
Publish by PR
- Sign the manifest, attach the bundle to a GitHub release, and add
- one entry to
catalogue.json by PR. Once merged,
-
pilotctl appstore install <id> works everywhere.
- See the
App Store docs.
+ Prefer git? The
pilot-app toolkit turns a
+
pilot.app.yaml into a complete, signed adapter bundle. Open
+ one PR to
pilot-protocol/app-template; CI verifies the bundle,
+ a maintainer reviews, and automation releases it and adds the catalogue
+ entry.
+
Get the toolkit →
+
+
-
Permissions
-
Agent-granular scope
+
Verified
+
Signed, checked on every spawn
- Apps declare what they need — network access, file I/O, specific
- protocols. The agent grants or denies at install time. No ambient
- authority.
+ Every adapter is sha256-pinned and signed by its publisher. The daemon
+ re-verifies the signature and binary hash each time it spawns the app, so a
+ tampered bundle never runs.
-
Distribution
-
Protocol-native
+
Scoped
+
Agent-granular permissions
- Apps are distributed through the Pilot Protocol itself. No app store
- servers, no CDN — the network is the distribution layer.
+ Apps declare exactly what they need — network access, file I/O, specific
+ protocols — and the agent grants or denies at install time. No ambient
+ authority.
diff --git a/src/pages/plain/app-store.astro b/src/pages/plain/app-store.astro
new file mode 100644
index 0000000..5a2c175
--- /dev/null
+++ b/src/pages/plain/app-store.astro
@@ -0,0 +1,55 @@
+---
+import PlainLayout from '../../layouts/PlainLayout.astro';
+---
+
+
+The Pilot App Store.
+
+The App Store is where agents find tools built specifically for them, and where builders publish their own. Every app is an agent-native interface — JSON in, JSON out — discoverable by the agents on the Pilot Protocol network. Install with one command, manage from one namespace, and submit your own apps anytime.
+
+Install and use an app
+
+ - Browse the catalogue:
pilotctl appstore catalogue
+ - Inspect before installing:
pilotctl appstore view <id>
+ - Install (the daemon spawns it locally):
pilotctl appstore install <id>
+ - Discover its methods:
pilotctl appstore call <id> <ns>.help '{}'
+ - Call a method:
pilotctl appstore call <id> <method> '<json>'
+
+
+What an app is
+
+ - A thin, stateless adapter plus a signed manifest.
+ - The daemon fetches the bundle, re-verifies its signature and binary sha256 on every spawn, and brokers JSON-in/JSON-out calls over a unix socket.
+ - The heavy backend (your API) lives wherever it already runs; the adapter forwards each method to it.
+ - Apps declare the permissions they need (network, file I/O, protocols); the agent grants or denies at install. No ambient authority.
+
+
+Publish your own app
+Two flows, same result: a reviewed, signed, catalogued app any agent can install.
+
+Browser (no code):
+
+ - Go to https://pilotprotocol.network/publish
+ - Describe your HTTP API: id (io.pilot.<name>), version, methods, backend URL, and any auth headers.
+ - The server generates, signs, and verifies the adapter. A reviewer approves it onto the store.
+ - No Go, no git, no manifest to write.
+
+
+PR (from the terminal):
+
+ - Install the toolkit:
go install github.com/pilot-protocol/app-template/cmd/pilot-app@latest
+ - Generate a spec:
pilot-app example > pilot.app.yaml, then edit it to point at your API and list your methods.
+ - Scaffold and package:
pilot-app init -o ./my-app, then make package in the project.
+ - Submit:
pilot-app submit -C . --prepare /path/to/app-template-fork, then open a PR to pilot-protocol/app-template.
+ - CI verifies the bundle; a maintainer reviews; on merge, automation releases it and adds the catalogue entry.
+
+
+Requirements to publish
+
+ - An existing HTTP API the adapter can forward to. CLI/binary apps are coming soon.
+ - A valid email for submission and review notifications (browser flow).
+ - Secrets are never collected; operators supply them at install time.
+ - Every submission is reviewed before it appears in the store.
+
+
+
diff --git a/src/pages/plain/publish.astro b/src/pages/plain/publish.astro
new file mode 100644
index 0000000..a7a41d7
--- /dev/null
+++ b/src/pages/plain/publish.astro
@@ -0,0 +1,52 @@
+---
+import PlainLayout from '../../layouts/PlainLayout.astro';
+---
+
+
+Publish an app.
+
+Bring your existing HTTP API. Describe it once and Pilot generates, signs, and verifies an agent-first adapter for it, then a reviewer publishes it to the app store. You do not upload code, and your secrets stay yours.
+
+Two ways to publish
+
+ - Browser wizard (no code): https://pilotprotocol.network/publish
+ - By PR (from the terminal): the pilot-app toolkit plus one pull request to pilot-protocol/app-template.
+
+
+Browser wizard steps
+
+ - Email: where we send your submission confirmation and the review decision.
+ - Identity: app id (io.pilot.<name>), version (semver), and a one-line description.
+ - Backend: the app type (HTTP API; CLI/binary is coming soon), the backend base URL, and any auth headers. Header values may use ${TOKEN} placeholders that the operator supplies at install — never stored in the app.
+ - Methods: each method an agent can call — name (<ns>.<verb>), HTTP route, latency class (fast under 5s, medium up to 15s, slow up to 1 minute), description, and parameters.
+ - Listing: display name, description, license, and categories for the store page.
+ - Vendor: who you are, how autonomous agents should use the app, and the list of capabilities.
+ - Review and submit: the server builds, signs, and verifies the adapter and stores it for review.
+
+
+Publish by PR
+
+ - Install:
go install github.com/pilot-protocol/app-template/cmd/pilot-app@latest
+ - Spec:
pilot-app example > pilot.app.yaml, then edit it.
+ - Validate:
pilot-app validate
+ - Scaffold:
pilot-app init -o ./my-app
+ - Package (build, sha256-pin, sign, tar):
make package
+ - Verify locally (optional):
pilot-app verify io.pilot.<id>-<ver>.tar.gz
+ - Submit:
pilot-app submit -C . --prepare /path/to/app-template-fork, commit submissions/<id>/, and open a PR to pilot-protocol/app-template.
+
+
+What happens after you submit
+
+ - CI verifies the bundle on the PR. (Browser flow: the server already built and verified it.)
+ - A maintainer reviews. On approval, automation releases the bundle on pilot-protocol/catalog and adds the catalogue entry.
+ - Then any agent can install it:
pilotctl appstore install <your.id>
+
+
+Requirements
+
+ - An existing HTTP API. CLI/binary apps are coming soon.
+ - A valid email (browser flow) for the confirmation and the review decision.
+ - You confirm you have the right to publish the app and agree to the Terms and Acceptable Use Policy.
+
+
+