Layers Growth MCP

Layers Growth MCP is one MCP server that a coding agent uses to run paid growth for your product on the Layers platform. First run is the ten-step paste below. Onboarding saves your product's brief and binds the repository to one Layers organization and project. Layers measurement is the Layers SDK in your app: install_growth_measurement returns the dependency, the app id and the init snippet, and its verify action reports when the first real event arrives. Then the person states a daily ad cap, which set_spend_cap records, and opens the signed Meta connect link on layers://workspace. The agent launches the first Meta campaign with launch_ads, and it calls one named outcome per job.

launch_ads launches in one call. It checks the app's daily spend cap first, runs Meta's validate-only check on every object, creates the campaign, ad sets and ads paused, reads each ad's live text, link and Page back from Meta, and turns them on only when every read-back matches. An app with a store listing gets an App Promotion campaign for installs, a product sold on its website gets a Sales campaign for purchases, and a waitlist or sign-up site gets a Leads campaign on its lead event, such as Lead or CompleteRegistration. halt with the project or organization scope pauses every Meta campaign a launch built, and the kill switch stops every turn-on. Trial cancellation is a preview-then-confirm call.

An Instagram account connects, satisfies onboarding, syncs, and is measured, and its own posts can be remixed. Discovery, delivery, and managed accounts run on TikTok today. No paid lane is certified yet: plan_paid_campaign refuses every platform until the Paid Growth lane ledger records a live-certified row for that lane.

Install

Set up Layers for this product: onboard it, install Layers measurement, then connect Meta and launch ads.
1. Install the CLI: run `npm install -g @layers/cli`.
2. Check that the README opens with a plain sentence saying what this product is, and write one if it does not. Setup sends that single line as the product brief, and it stops with exit code 1 when it cannot find one.
3. Set it up: run `layers setup` from this repository. It prints one line, "Send this to the person: <link> (code <code>)". Send me that link and code; I tap the link, check the code matches, and tap Allow. It also opens a browser on this machine when there is one, and either way finishes the sign-in. The link works for 15 minutes, and running `layers setup` again after a restart resumes the same link. It writes the `.mcp.json` entry and the Layers skill into the repo and stores the session in the OS credential store, so nothing secret lands in the repo. On a machine with no OS credential store, such as a Linux cloud computer, run `layers setup --allow-file-credentials` instead, which keeps the session in a private 0600 file. If it asks for the product's public URL, which is its website, its App Store page, or its Google Play page, pass that question to me. Setup also onboards the product: Layers saves the README line and the public URL as this product's brief.
4. Check the organization: when setup creates the project, its summary names the organization the project is in and says how to put the project in another one. Send me that organization line. If I name another organization, follow those instructions.
5. Read the skill at `.agents/skills/layers/SKILL.md`. If this session cannot load the Layers MCP server, as in a headless run, call a tool with `layers call <tool> '<json>'` and read a resource with `layers call layers://<resource>`; both reach the same tools and resources.
6. Install Layers measurement: call install_growth_measurement with action spec. For an Expo, React Native or Flutter app, send platforms with that framework, such as ["expo"]; the response lists the platforms the spec covers. When the product has a website to promote, send webDomain set to its host name, such as example.com. It returns the SDK dependency, the app id and the init snippet for this app. Add them to the app, run the app once on a simulator, a device or in a browser, then call install_growth_measurement with action verify until it answers reporting.
7. Set the daily cap before any launch: ask me "What is the most you want to spend on ads per day, in US dollars?" and set my answer with set_spend_cap. The cap is a 7-day average, so one day over it is fine.
8. Connect Meta: read layers://workspace. The meta-ads row of paidReadiness.providers carries a signed connect link. Send me that link; I open it and choose the ad account, the Facebook Page the ads run as and, for an app with a store listing, its Meta app. Every Meta ad runs as a Facebook Page. If I have none, the page links to where I create one; when I tell you the Page is ready, send me a new connect link. Wait until that row reads configured.
9. Make the ads: write the primary text and headline and make the images for each market, in that market's language and sized for Meta placements. Save each image inside this repository: launch_ads takes it as media with source local_file and the file's path, and the layers CLI uploads it. An image already at an https address goes as source image_url with that url. Show me the copy and the images before you launch.
10. Launch: call launch_ads with action launch, a dailyBudget within the cap in the ad account's currency, currency, markets and the creatives. An app with a live App Store or Google Play listing gets an App Promotion campaign for installs. A website product, such as a web app, a SaaS, a store or an info product, gets a campaign whose ads link to the website and optimize the conversion its Meta Pixel received in the last 28 days: a Sales campaign for Purchase, else a Leads campaign for a lead event such as Lead or CompleteRegistration from a waitlist or sign-up form. An app with no store listing yet launches only through its website, or waits for the listing. launch_ads returns each blocker with its fix; do the fix and call it again. While Meta reviews the ads, the launch answers status running; call launch_ads with action status and its jobId until it finishes.
Let me know when it is ready.

Paste that into Claude Code, Codex, Cursor, or any coding agent working in your repository: the agent runs the commands and the tool calls. A person taps the sign-in link, answers the daily ad cap question, and opens the Meta connect link.

Setup prints a sign-in link and code for the person to open, and opens a browser when the machine has one. It stores the session in the operating system credential store, or with --allow-file-credentials in a private 0600 file on the machine, so no token, key, or header is written into the repository or into your agent's configuration. layers mcp and layers call are the credential's only readers.

MCP clients read .mcp.json when they start, so the entry setup writes reaches the client on its next start or after /mcp. In the session where setup just ran, layers call <tool> calls the same tools over the same sign-in. Claude Code holds a new repository server pending until you approve that entry once; setup reports project_config_pending_approval and names the exact entry to approve.

Manual setup

If you would rather run the commands in a shell:

npm install -g @layers/cli
layers setup

What setup writes

Every file above is safe to commit. Setup is idempotent: running it again repairs Layers-owned entries, leaves every other MCP server entry byte for byte as it was, and creates no second project. For a client that does not read the repository .mcp.json, setup registers the server through that client's own command, such as codex mcp add layers -- layers mcp.

The tools

Twenty-seven outcomes make up the catalog. Prices are in credits and every charge is quoted before the work runs. The Credits column lists each charged action; anything not listed there is free. tools/list in your session is the authority on what your agent can call: a tool is there because it ships, and a tool Layers withdraws is deleted from the catalog by a release rather than switched off under you.

Three profiles, and a project has to have a profile enabled before its tools admit a call. Growth is the default.

Growth

A creative edit changes the script, opening, caption, or tags, and it is free however many times you make it. A structural revision changes the source, hypothesis, controlled variable, format, target account, or schedule, and it costs the same 6 credits as a new plan because the server recomputes the plan. Every revision is recorded and supersedes the previous one.

One render_content call starts one generation and returns one job, so it charges one rate. Rendering more is calling again. An unusable output is refunded. Reading stored results costs nothing, and a forced refresh that causes no provider read creates no debit.

Paid media

Ad spend is your own money at the provider. It never consumes credits and never hides inside a credit quote, and every campaign runs under a spend authority a human granted.

The daily spend cap is the number you state for your app, set through your agent with set_spend_cap. It is a 7-day average: one day over is fine. create_approved_campaign_draft, launch_approved_campaign and apply_approved_campaign_change are off tools/list and still callable by name.

The six granular tools take a network field, meta today, with each network's own fields as its arm of the input. A create is always paused. A project with no connected Meta ad account answers PROVIDER_NOT_READY with a connect link, and a write that outlives the call answers pending; the same call with the same idempotencyKey reads the outcome.

set_daily_budget moves one campaign's daily total. delete_campaign removes the campaign at the provider, including one that is delivering right now, and a deleted campaign cannot be resumed. Both preview for free, both cost 5 credits on confirm, and both report success only after the provider reads the change back.

Managed distribution

A Layers-operated fleet is billed in dollars from the organization's cash wallet, at $150 per account per month. That is separate money from credits.

MMA (Mobile Measurement Agent)

A studio that measures its app in MMA gets the same numbers in its coding agent. Run npm i -g @layers/cli && layers setup in the app's repository. Setup binds the repository to one organization and one project; in a studio with several apps, layers setup --project prj_<id> names the app. The agent then reads the app's MMA screens as resources (listed under Free resources) and records the product experiments it runs, which show on MMA's Experiments page. Every read and write uses your own sign-in and MMA's own rule: studio membership and access to the app. Approving a recommendation stays a click in MMA.

An agent that runs unattended (a scheduled Claude Code or Codex run, a GitHub Action) signs in with an MMA API key instead. Create one on MMA's API Keys page with Read MMA over MCP and the app it reads, then send it as Authorization: Bearer <key> together with the x-layers-organization-id (org_<uuid>) and x-layers-project-id (prj_<uuid>) headers. For that app the key reads the layers://mma resources, list_mma_experiments, get_mma_experiment, list_mma_reviews, get_mma_ratings, get_mma_cohorts, get_mma_retention, get_mma_insights and get_mma_pockets, and marks its own inbox read with mark_mma_inbox_read. get_mma_studio_brief and run_events_sql also need only Read MMA over MCP (mma:read). get_mma_studio_brief takes no input. An app-scoped key receives only its bound app's brief, without studio-wide decisions or alerts; an org-wide key or a signed-in person receives every app in the studio. The result states scope as app or studio, and mmaUrl opens the studio Brief page. Each write tool below needs one more permission on the key: Manage experiments (experiments:write) for register_mma_experiment and update_mma_experiment, Request decisions (decisions:write) for file_mma_decision and withdraw_mma_decision, and Write Shipyard records (shipyard:write) for the Shipyard tools. Prototype gates are set by a person; a key proposes a change with file_mma_decision.

Each wake-up starts at layers://mma/inbox: what changed for the app since the agent last marked it read (experiment reads due, answers to its asks, spend against the daily cap, broken signals, next steps). Reading it marks nothing; mark_mma_inbox_read with the read's readAt does. The layers-status prompt runs the whole check-in, and hosts that do not show MCP prompts use the layers-status skill.

What onboarding sends

Your agent reads the repository on your machine and submits a short product brief: name, one-line description, category, target users, the problem, the conversion goal, seed keywords, known social handles, and store identities. Layers never receives your source code. No file, path, diff, or excerpt is sent. The request carries the brief fields, one digest, and a closed list of evidence classes such as package_manifest and readme.

Onboarding writes the brief and the store identity and finishes on the same call. It needs no social account and starts no background jobs. The calls after it are create_app, which registers the app's iOS bundle id or Android package and issues its App ID on the bound project, and install_growth_measurement, which puts the Layers SDK in the app and confirms it reports.

A project onboarded from an App Store or Google Play listing also gets its mobile app layer, its store listing record and its bundle id at the same moment, which is what lights the App Store Optimization surface in the app.

It creates no schedule, campaign, managed account, standing automation, provider mutation, or charge.

Free resources

Resources read stored state. They are free, they never trigger a provider read or a model call, and each one reports when its data was observed and which tool refreshes it.

A client without MCP resource support gets one extra read-only tool, read_layers_state, which returns the same data and makes the same authorization decision. It reaches every resource above except layers://campaigns, so a paid-media projection needs a resource-capable client.

Skills

The server owns the skill bodies and setup installs one thin pointer at .agents/skills/layers/SKILL.md. The pointer names the server, the project binding rule, and the pinned major version. Skills carry judgment about when to use an outcome and how to read the result. They hold no credentials, no prices, and no tool of their own.

Pricing

Credits pay for the work the agent asks for. One organization holds one credit balance, and the same operation costs the same number of credits on every plan.

Pay as you go costs nothing a month and includes no credits. It needs a card, and credits are bought in packs at 2 cents each. It is the way in for a workspace that wants to pay for exactly the work it asks for.

The trial is the first week: 7 days, $9 today, a card required, and 1,000 credits. The first landscape build is included, so the trial can reach opportunities without spending them. The trial converts to Pro monthly at $49 unless it is cancelled first, with the $9 credited toward the first month.

Subscriptions auto-renew until a human cancels them. Your agent can cancel the trial renewal for you with cancel_trial_auto_renewal: the first call previews the trial end, the effective date, what you keep, and what you lose, and returns a link. Cancellation itself takes your click on that Layers page. No MCP tool can complete a checkout, start a plan, or change a renewal on its own.

One-time packs add credits to the same balance and do not expire. There are two sets of prices, and a workspace buys from the one its plan puts it on.

layers://account reports which set applies to you, at creditPacks.eligibility.observed.packAudience, and every pack price it lists is the price your card is charged. A checkout link for the other set is refused.

Ad spend and managed-account fees are separate money. They never consume credits and never hide inside a credit quote.

Available today

Verified against the server source on 2026-09-02. tools/list in your session is the authority: every tool in the tables above is in the catalog, and a bound project can call it.

Every profile is on for a bound project, so paid media and managed distribution need no separate enablement, and neither adds a network-prefixed or provider-prefixed tool.

A few of the growth outcomes carry detail the table has no room for.

• manage_growth_landscape charges only for a refresh. A full rebuild costs the same six credits as a forced incremental one and runs the same discovery crawl.
• find_growth_opportunities reads the stored queue. The default read starts no vendor call, no model call, and no charge. includeCreativePreview: "generate" makes the creative analysis for the returned cards that have none yet, at two credits for each preview actually produced and nothing for a card it could not analyze; each one is cached, so a later read of the same card is free. quoteOnly returns the same cards and that price without producing anything.
• generate_influencer is free. layers://influencers is where the persona is read back once its portrait lands, and slateUrl on both surfaces opens a page of the project's portraits for a person to look at.
• render_content renders one output a call. A remix reads video or slideshow off the post it adapts and charges the matching rate; layers://brand-assets and layers://music are where the screens and the track it can be directed with are read.
• The five research_tiktok_* reads each cost one credit a call whatever the row count, charged on the call. research_tiktok_trending_sounds and layers://music answer different questions: the chart is what TikTok is playing, and the resource is what a render may legally be scored with.
• review_growth_results reads stored evidence for nothing and pays one credit only for a forced provider sync.
• halt covers one job, one experiment, one social account, one paid campaign, one managed account, or the whole project. On a campaign it pauses provider delivery and withdraws the approvals that campaign holds.

Two earlier surfaces were retired on 2026-08-30 with no bridge and no compatibility shim: the npm package @layers/mcp-server, including the keyless onboarding mode it started in without a key, and the growth MCP that served the protocol at growth.layers.com. Do not install or call either one. That hostname now serves the landing site for this server and no protocol. The Growth page covers the retired growth MCP. The product contract for this server, including where the outcome of every retired tool went, is docs/specs/layers-mcp-product.md in the Layers repository: section 15.2 for the 26 growth tools and section 15.3 for the 52 API-backed tools and the five keyless tools. The REST routes those tools mirrored are unchanged.

Support

Ask in the in-app chat at app.layers.com, or email support@layers.com. For a security report, email security@layers.com.

Layers also has a public REST API for building against the platform directly. See API.