Software now gets built through an agent. A founder describes the product in a terminal, and the agent writes the code, wires the pieces together, and puts the thing on the internet.
The striking part is not the code. It is how much of the surrounding infrastructure has become addressable by software. Hosting is one command. A Postgres database is one command. Auth, object storage, a queue, background jobs, payments: each one is a package, a key, and a few lines the agent writes without being asked twice. The founder never opens a dashboard. Whole categories of tooling quietly became things an agent installs.
Then the product goes live, and the agent runs out of road. There is no command for distribution. Being found is still a browser-tab job: a keyword tool in one tab, an answer engine in another, a competitor page, a community thread, and a notes document where the findings go to die. The one part of shipping a company that nobody automated is the part that decides whether anyone ever sees it.
- Coding agents can install hosting, a database, a queue and payments in one command each. Growth has no equivalent primitive, so it stays manual.
- AfterLaunch exposes an always-on growth engine to software: an MCP server plus a public REST API over the same Feed the founder works from in the browser.
- The engine works continuously across AI answer engines, search, competitors and communities, and prepares ranked moves with the draft already written.
- API keys are scoped (read, write, config), every metered action claims before it spends, and social publishing stays review-and-post by a human.
- Starting is free. Any active account mints a key from Settings, or an agent can onboard its founder through an approval-first flow.
The primitive that never arrived
Infrastructure became agent-addressable because it had a shape agents could hold: a stable API, a scoped credential, a documented set of verbs, and a clear answer to what happens when a call is repeated. Once a category has that shape, an agent can use it without a human translating.
Growth tooling never took that shape. The category grew up around dashboards, and a dashboard is a surface for a person to look at. It reports rather than acts. It hands back a chart and a problem, and the response, the page to write, the comparison to publish, the thread to answer, lands on the founder who already has no hours. The agent that built the whole product cannot help with any of it, because there is nothing for it to call.
That is the gap. Not a missing feature in an existing tool, a missing primitive in the stack.
The growth layer an agent can wire in
AfterLaunch is an always-on growth engine for a post-launch product, and it carries a machine surface built for exactly this. There is an MCP endpoint at /api/mcp and a REST API under /api/v1, both authenticated with a scoped key. Both are generated from one action registry, so the two surfaces cannot drift and nothing ends up exposed by accident.
Behind that surface, the engine keeps working between calls. It is not a request-response wrapper around a model. It runs loops:
- AI Visibility. How ChatGPT, Gemini, Perplexity and Google AI Overviews describe the product when someone asks for a tool like it, and who gets named when it is not.
- SEO. A site-wide audit that produces specific, applicable fixes rather than a score.
- Competitors. Where the product stands against the set it actually competes with in answers and in search.
- Communities and channels. Where the buyers are already asking the question the product answers.
All of it converges on one object: the Feed, a persistent ranked backlog of prepared growth moves. Each move carries a title, why it matters, a rank, a status, and the full draft body of the work itself. That is the object the API hands an agent, which is what makes it useful. A ranked list of things to do, with the writing already done, is something software can act on. A trend line is not.
What a session actually looks like
Concretely, from an agent that has just finished a deploy.
Connect
One command points an MCP-capable client at the endpoint and carries the key. In Claude Code that is: claude mcp add afterlaunch --transport http https://afterlaunch.io/api/mcp --header "Authorization: Bearer al_...". REST callers skip the command entirely and send the same Authorization header to /api/v1.
Confirm what the key is bound to
The handshake is whoami, and it is deliberately the first call. It returns the product run the key is bound to, the key name and its scopes, the product URL, the tier and the trial end date, and, while credit metering is live, the credit balance. An agent that starts here never has to guess which account it is holding or what it is allowed to do with it.
Read the Feed
list_feed returns the live backlog by default: title, why it matters, status, rank and the full draft_content body, plus a count of the live moves. Passing include_resolved widens it to the shipped, skipped, archived and expired ones, which is how an agent works out what has already been tried. Around it, get_loop_status reports which loops are provisioned for this product and how much autonomy each one has, and list_outputs and get_output return drafted outputs by id.
Act on a move
ship_move marks a move shipped, the same action as the Ship button in the browser, with an optional asset_url when the move published something live. skip_move dismisses one with a reason drawn from a closed feedback vocabulary, so the dismissal teaches the next batch instead of vanishing. update_draft replaces a pending draft body with an edited version before it ships. archive_move removes a move from the Feed without recording a verdict. All four are free, and all four run on the act scope, which every key carries by default.
Three tools spend money and say so in their own descriptions. refresh_scan runs an on-demand AI Visibility scan. replenish_feed runs the move generator to top up the Feed. run_loop triggers one generation run of a provisioned loop. Each takes an idempotency key the caller mints, and each is limited per cycle: one scan per scan type per product per local day, one replenish a day per product, one run per loop per product per cycle. A repeat inside the same window replays the original result rather than running, or charging, again.
Set the terms
set_loop_autonomy moves a loop along the rungs from review to one click to autonomous. set_loop_cadence sets how often a loop runs: default, biweekly, monthly or paused. It can only slow a loop or stop it, never make it run faster than its normal cadence. Both need the config scope.
| Scope | What a key with it can do | Tools |
|---|---|---|
| read | Read the product run, the ranked Feed, the loops and the drafted outputs | whoami, get_enrollment, list_feed, get_loop_status, list_outputs, get_output |
| write | Act on moves, and trigger the metered work that costs credits | ship_move, skip_move, update_draft, archive_move, refresh_scan, replenish_feed, run_loop |
| config | Change a loop's autonomy rung or its cadence | set_loop_autonomy, set_loop_cadence |
The honest posture
Handing an agent a growth engine raises a fair question: what stops it going wrong at speed. The answer is not trust, it is structure.
- Keys are scoped and named. Keys minted in Settings carry read and act: they can read the run and act on a move, and they cannot spend a penny. The metered actions need the write scope and the autonomy levers need config, both issued by AfterLaunch, and a key only ever binds to the product run it was minted for.
- Spend is bounded rather than trusted. Metered actions claim before they spend: credits, a caller-minted idempotency key, a per-cycle limit, and per-tenant daily and monthly spend caps underneath all of it. An agent stuck in a retry loop on refresh_scan gets the first result replayed, not a second bill.
- Social publishing stays review-and-post by a human. Social channels never accept the autonomous rung. An agent can draft, edit and queue; a person posts.
- Onboarding cannot spend at all. The agent-driven flow is approval-first, rate limited, and capped at one free trial per site, and the only side effect it can cause before a founder approves is a single email.
None of this is a wall around the interesting parts. It is the same shape every other agent-addressable category settled on: a scoped credential, documented verbs, and a defined answer to what a repeated call does.
Where to start
It is free to begin. Any account on an active trial or a paid plan mints an API key from Settings, names it, and hands it to an agent. The key reads the Feed and acts on it, so one command later the agent can pick up a move and ship it.
If the founder is not enrolled yet, the agent can start that too. It submits the site and the founder's email address, the founder receives one approval email, and nothing runs until they click it.
Read: How an AI agent sets up its own growth engine →The full machine surface, with the endpoints, the tool list and the auth model, lives in the developer docs.
Developer docs: the API and MCP surface →Do I need to use an agent to use AfterLaunch?
No. The browser product is the same product. The Feed, the signals and the drafts are identical whether a person reads them on a page or an agent reads them over the API, because both surfaces sit on one engine. The machine surface is an additional way in, not a separate tier of the product.
Which agents can connect?
Any MCP-capable client can connect to the MCP endpoint with a bearer key, and anything that can make an HTTPS request can use the REST API under /api/v1. The tool list and the OpenAPI description are generated from the same registry, so both surfaces describe exactly the same capabilities.
Can an agent post to my social accounts on its own?
No. Social channels never accept the autonomous rung, so a person always reviews and posts. An agent can draft in your voice, edit a pending draft and mark a move shipped once the work is out, which keeps the loop moving without handing over the account.
What stops an agent running up a bill?
Every metered action claims before it spends. It needs the write scope, which AfterLaunch issues separately from the act scope that covers the free actions, plus an idempotency key, and it is limited per cycle, so a repeat in the same window replays the original result instead of running again. Underneath that sit credits and per-tenant daily and monthly spend caps.
Run the free Growth Snapshot. It reads your product the way an assistant does, shows where you are named and where you are invisible, and turns that into the ranked work your agent can pick up over the API.
Run your free Growth Snapshot