You have an API. Agents should be able to call it.
You built a service — maybe a weather lookup, a company research endpoint, a code sandbox, a price feed. It works fine when a human pastes a curl command. But an autonomous AI agent? It needs discoverability, typed inputs, a contract it can read before calling. It needs an agent app.
This is the walkthrough for someone who already has an API and wants to drop it into the Pilot app store — where agents discover, install, and call it with one command.
What "publishing an agent app" actually means
An agent app on Pilot Protocol isn't a container or a server you ship. It's an adapter — a typed JSON-in/JSON-out description of your API's methods that the local Pilot daemon installs as a supervised IPC service. Agents on the network install it with one command and call your API without writing any integration code.
The publishing process is: describe your app → they build and sign the adapter → the team reviews → it's live in the catalogue.
You never upload code. You never hand over your API keys. You describe what your methods do, and Pilot generates the adapter for you.
Before you start
You need:
- A working API (public or with a documented shape). Agents call it over the internet, so it needs to be reachable.
- A valid email. Pilot uses this to send you a submission confirmation and the review decision.
- A name and a short description for your app. Think about what an agent would search for.
That's it. No SDK to install, no container to build, no repository to maintain.
Step 1: Go to the publish page
Navigate to pilotprotocol.network/publish. The form is a 7-step wizard — it walks you through everything in order.
⚠️ The page shows a "Publishing needs a desktop" notice on small screens. Open it on a desktop browser to see the full form.
Step 2: Email (Step 1 of 7)
Enter your email address. Pilot sends a confirmation so they can reach you about your submission and the review decision. This is also where you'll get notified when your app goes live or needs changes.
Step 3: Identity (Step 2 of 7)
This is about who you are as a publisher. You provide your name and optionally a handle or organization name that appears alongside your app in the catalogue.
Step 4: Backend (Step 3 of 7)
Describe the backend your app talks to. This is the API base URL or endpoint. You don't upload credentials — Pilot's model is that secrets stay with the operator. At install time, the person running the agent supplies their own API keys for your service.
Step 5: Methods (Step 4 of 7)
This is the meat of the submission. Each method is one thing your API does. For each method you describe:
-
Name — a short identifier agents use to call it (e.g.
search,lookup,analyze) - Description — what this method does, in plain language the agent's LLM can read to decide whether to call it
- Input parameters — what the agent sends you (name, type, required/optional, a description)
- Output shape — what your API returns
The Pilot team uses these descriptions to build a typed JSON adapter. An agent that installs your app calls <app>.<method> with JSON input and gets JSON output — no curl, no parsing, no conditional branches.
Make your descriptions agent-friendly. A good method description reads like "Search for a company by domain name and return its industry, employee count, and head office location" — not "POST /v2/search with q param."
Step 6: Listing (Step 5 of 7)
Catalogue details: a full description for the app store listing, a logo or icon URL if you have one, and a website link. This is what agents (and humans browsing the app store) see.
Step 7: Vendor (Step 6 of 7)
Contact details and any support URL. Pilot uses this if there's an issue with your app. It's also how the review team reaches you during the approval process.
Step 8: Review and release (Step 7 of 7)
The final step shows you a summary of everything you entered. Before submitting you confirm:
- You have the right to publish this app and grant Pilot permission to distribute it
- You agree to the Terms, Acceptable Use Policy, and Publisher Release Agreement
Submit when ready.
What happens next
Pilot's team reviews your submission. The review checks that:
- The method descriptions match what the API actually does
- The adapter it generates works correctly
- The app doesn't violate the Acceptable Use Policy
Once approved, your app appears in the app store catalogue. Any agent on the network finds it with:
pilotctl appstore catalogue
And installs it with:
pilotctl appstore install <your-app-id>
Your API is now an agent-native tool. No additional code on your side. No integration maintenance. The agent calls it as a typed service — JSON in, JSON out, supervised by the daemon.
What kind of APIs make good agent apps
The best candidates are APIs that an autonomous agent would naturally reach for:
- Lookup and research APIs — company data, person enrichment, domain info, patent search
- Price and market data — crypto, FX, stocks, commodities
- Weather and environmental data — forecast, air quality, marine, wildfire
- Translation and language services
- Code execution or sandbox APIs
- Any API you'd want an agent to call without you writing integration logic
If your API already has a documented REST shape and you can describe each endpoint's intent in a sentence, it's a good fit.
No-code publishing, agent-native consumption
The loop is asymmetric by design: you publish without writing code, and the agent consumes without writing code. The adapter Pilot generates for you is signed and verified — the daemon re-checks the manifest's sha256 hash and ed25519 signature each time your app is spawned, so the agent never runs an untrusted adapter. At install time, the operator's secrets stay with the operator — your app just defines the shape.
This is the same model that lets agents chain multiple Pilot apps into a single workflow: install a research app, a web scraping app, and a notification app, and the agent calls them in sequence, piping JSON output to JSON input, without you ever writing a line of middleware.
Ready to publish?
Head over to the publish page and start the 7-step wizard. Describe your app, confirm your email, and let the platform generate the adapter. Your API becomes an agent-native tool in a single submission cycle.
Top comments (0)