Access and approvals
Your agent works in Ploa with a token. The token's level sets what it may touch and what it may ask for, and whatever can't be undone (App Review, production, prices, testers who get an email, replies under reviews) waits for your approval, unless you made that agent autonomous.
The four levels
Each token has one level, and a higher level includes everything below it. You choose it when you approve ploa login, when you make a token, or later in Settings › Tokens, where a change takes effect at once and the agent keeps working.
| Level | What it may do |
|---|---|
| Read | See the apps, builds, the stores' state, the store page, reviews, sales and reports. Changes nothing. |
| Draft | Write drafts (store text, privacy and export compliance answers), link and add apps, build and send builds to testers (TestFlight, Google Play internal testing, a web version's testing address), stop a build, and work on the app's web and server. It may ask for: linking a GitHub repository, the app's GitHub settings, build files, and steps only you can do. |
| Submit for review | Also send changes straight to the stores (the store page, screenshots and videos, TestFlight groups and What to Test), and ask for App Review, testers, products, offers, RevenueCat, replies under reviews, product pages, A/B tests and In-App Events. |
| Production | Also ask for production releases, Google Play rollouts and halts, the App Store release and its phased release, the App Store price and release option, and a web version going live. |
An agent can only ask for what its level allows: a Draft token's request for App Review is refused, not sent to you. For an agent that takes the app all the way to the stores, pick Submit for review, or Production for releases and prices.
The level is the most a token may do; what an agent does is narrower. Ploa's briefs keep agents to drafts for the store page: they save, and you send it to the stores with one click, unless the agent is autonomous. And a token never sees a secret's value, never decides a request (its own or anyone else's), and never makes another token.
A member's agents
A token never does more than the member it belongs to. Owners choose what each member may do (Apps and builds, Store page, App Review and production, Reviews, Stores, keys and GitHub, Sales and revenue, Agents and tokens, Plan and billing, Security, Autonomous agents; see What a member may do), and a member's agents and tokens get exactly that. A refusal names the permission an owner hasn't given. Deciding an approval takes the permission for what it asks, and when an autonomous agent's member lacks that permission, its request waits for someone who has it.
Where tokens come from
ploa loginon a computer: you confirm the code on ploa.dev and choose the level there (Submit for review is chosen by default). Owners, and members given the permission, can also choose Autonomous agent.- Settings › Tokens on the dashboard: for CI, servers and
PLOA_TOKEN. The token is shown once. - The web server (
ploa.dev/mcp): when you approve an agent, you choose Read only, Drafts and builds, or Drafts, builds and requests, and the token is named after the agent, with "(web)". By itself it never goes past drafts and builds; with requests it asks you for everything in the table below, and each request waits for your approval. It can't be autonomous or change the stores directly; for that, use the agent on your computer. Change its choice in Settings › Tokens.
Every token is listed in Settings › Tokens with its level and last use, and can be revoked there. The workspace's owners are told whenever one is made. Builds Ploa runs on GitHub sign in as the run itself, with a short-lived token that can change nothing but its own build.
What waits for your approval
When an agent or the CLI calls one of these, it's asked for, not done. The level each one needs is fixed by Ploa, not by the caller. On the dashboard, you do them straight away.
| What | Level to ask | From the agent |
|---|---|---|
| Submit an iOS version for App Review, or send a newer build in place of the one App Review has | Submit for review | ploa_release_submit_review |
| Take a version out of App Review | Submit for review | ploa_release_withdraw_review |
| Promote an Android release to production (or beta, alpha), as a staged rollout or to everyone | Production | ploa_release_promote |
| Release the version App Review approved on the App Store | Production | ploa_appstore_release |
| Change a staged rollout: resume or finish an App Store phased release, or a Google Play rollout's share | Production | ploa_appstore_phased_release; Google Play's on the dashboard |
| Halt a release: pause an App Store phased release, or stop a Google Play rollout | Production | ploa_appstore_phased_release; Google Play's on the dashboard |
| Change the App Store price | Production | ploa_details_save (price), ploa_details_send |
| Choose whether an App Store version is released as soon as App Review approves it, or by you | Production | ploa_appstore_release_type |
| Put a web version live at its address and domains | Production | ploa_web_release |
| Invite TestFlight testers (Apple emails each one) | Submit for review | ploa_testflight_save |
| Send a build to TestFlight's beta review | Submit for review | ploa_testflight_save |
| Change who tests on Google Play | Submit for review | ploa_play_testers_save |
| Move testers to the newest build and expire older TestFlight builds | Submit for review | The dashboard |
| Create an in-app product or subscription, or change its price | Submit for review | ploa_product_save |
| Create or price a subscription offer, or make offer codes | Submit for review | ploa_offer_save, ploa_offer_codes |
| Create a product in RevenueCat | Submit for review | ploa_revenuecat_create_product |
| Send an in-app product to review, or put it on sale | Submit for review | ploa_product_submit |
| Reply under a customer review | Submit for review | ploa_review_reply |
| Send a custom product page or an A/B test to App Review, or start or stop a test | Submit for review | ploa_marketing_save |
| Send an In-App Event to App Review | Submit for review | ploa_event_submit |
| Send changes kept for App Review to the App Store now, rather than when Apple decides | Submit for review | ploa_held_changes |
Add build files from a checkout (google-services.json, .env…), for builds on GitHub | Draft | ploa_build_files_push |
| Link the app to its GitHub repository | Draft | ploa_github_setup |
| Change the app's GitHub settings (PR labels, iOS on GitHub's Macs, Releases on GitHub, the store page from the repository, issues from the stores). iOS on GitHub's Macs spends GitHub minutes, so an owner, or a member with the Plan and billing permission, approves that one | Draft | ploa_github_settings |
| Something only you can do: a form in a store's console, a declaration, an agreement | Draft | ploa_ask_person, or filed by Ploa itself |
Stopping a build, sending the store page and the Data safety form, and the export compliance declaration are each handled their own way: see Stopping a build and What only you send.
How an approval works
- The agent asks
The tool returns at once with a request ID and a link. The agent tells you what it asked for, in a line.
- You're told
The request appears on the dashboard's Approvals page and on the app's pages, and as a notification on your phone and computer if you turned them on.
- You decide
Approve, or reject with a reason the agent sees. Deciding takes the permission for what the request does.
- Ploa carries it out
Ploa sends it to the store, and the agent reads the outcome with
ploa_approval_status. If the store refuses, the request shows why.
A request nobody decides expires after 7 days; build files after 24 hours, and unapproved files are dropped then. The agent never looks for another way around a request: it waits, or asks you.
Steps only you can do
Some store steps have no API: Apple's App Privacy, Play Console's App content forms other than Data safety, agreements only the Account Holder accepts, declarations that are your own statement. These come to your Approvals page as tasks, filed by Ploa when a store stops a request, or by the agent with ploa_ask_person. Each task has numbered steps with the exact answers and the console's link; you do it in the console and press Did it. The agent walks you through the same steps in chat. A task is never approved in advance, even for an autonomous agent.
What only you send
- The store page: the agent saves drafts; you check them and send them all with one click on the Store details page. An autonomous agent may send them itself (
ploa_details_send). - Data safety replaces what Play Console has, and the export compliance declaration is your statement to Apple, so you send them yourself (or an autonomous agent does).
- Saying App Privacy or a Play declaration was entered in the console is a tick you make in Ploa yourself, and adding the Android upload key is yours too, unless the agent is autonomous.
Stopping a build
Stopping a build isn't an approval, but it isn't done in one call either. ploa_release_stop first says what stopping does where the build runs; the agent shows you, and stops the build only once you say yes. The dashboard and the build's timeline then name the agent that stopped it.
Autonomous agents
An autonomous agent works without waiting for you. What would wait for approval (App Review, production, prices, testers, products, RevenueCat) is approved in advance and done at once, and the store steps otherwise left to you (adding store and signing keys, connecting RevenueCat, app settings, saying App Privacy or a Play declaration was entered, sending the store page) are open to it. Its token has the Production level.
Even then, these stay with you and your team: deleting anything (apps, store keys, signing keys, RevenueCat), deciding other agents' requests, members, invites, tokens, passkeys and sessions, the vault and the audit log, and the steps only you can do in a store's console.
- Who can turn it on: you, for your own token and signed in, if you're an owner or a member given the Autonomous agents permission. When approving
ploa login, when making a token, or later in Settings › Tokens, where you type a word to confirm. - Never the agent: an agent can ask for it (below), never give it to itself. An agent on the web can't be autonomous at all.
- A member's agent still does no more than its member may: a request their permissions don't cover waits for someone whose permissions do.
- Ending it: picking another level for the token, or revoking it.
Everything is still recorded. Approvals show "approved in advance by an autonomous agent", and the audit log names the token. Autonomous agents are on every plan, Free included.
Choosing at the start
When your agent starts working with Ploa (ploa_setup_guide), and until you've chosen, its first question is how it should work:
- Autonomous agent: it acts at once, App Review, production, prices, testers and products included, and everything is recorded under its name.
- Approvals: each review, release and price change waits for your OK in Ploa, from the notification or the Approvals page; it prepares everything else.
It records your answer with ploa_access. Choosing approvals takes effect at once, and the agent doesn't ask again. If its token is at Read or Draft, it tells you it can't even ask for reviews and releases yet, and links Settings › Tokens, where you raise it to Submit for review or Production.
Autonomous is only a request: the agent gives you a link that opens Settings › Tokens on that agent's token, where you, signed in, read what it means, type the word and confirm, or keep it on approvals. Until you do, it works with approvals. If you may not confirm it (a member without the permission), it says so: an owner gives you the permission under Members first, or keeps the agent on approvals.
The dashboard's Get started card offers the same choice, and a token whose agent asked shows it on its row in Settings › Tokens. You change it there any time.
Watching what agents do
- Agents board: what each agent is working on, what waits for you, what's stuck and what finished this week.
- Release runs: every release step by step, with who started it, on the app's pages and through
ploa_runs. - Audit log: every change, by whom and from where, in a hash-chained log nobody can quietly edit.