Skip to main content
Glama

Server Details

Shipfound turns Claude Code or Codex into a growth engineer: site fixes for Google and AI search, content briefs and checks, indexing, AI crawler tracking and AI visibility checks. Changes go out as pull requests the founder merges. Sign in with OAuth.

Ownership verified
Status
Healthy
Uptime
100.0% over the last 24 hours
OAuth
Works in Glama
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
ChatGPT
–
Claude
–

TDQS

B3/5.0

Scored across 136 tools

Disambiguation2/5

The set has many closely overlapping clusters, especially around outreach and research: outbound_targets, outreach_targets, reach_find, drop_threads_find, bullseye_*, trumpet_*, and ideas_replies_find all involve finding people or pages to contact, with boundaries that are hard to hold in mind. Similarly, research/research_run/visibility/visibility_run and boost_record/boost_check/boost_results require nuanced distinctions. Descriptions help, but the sheer number of adjacent tools makes misselection likely.

Naming Consistency3/5

Almost all names use snake_case and many follow clear domain prefixes such as app_*, ads_*, boost_*, seo_*, grow_*, and notes_*. However, the set mixes bare nouns (today, plan, workspace, access, research, visibility), branded names (trumpet, bullseye_plan, ladder), and inconsistent verb/noun patterns, so it is readable but not predictably consistent.

Tool Count1/5

At 136 tools, the surface is far beyond a well-scoped set and creates a serious discoverability and selection burden. Even for a broad growth platform, this many tools is an extreme mismatch; many adjacent tools could likely be consolidated or grouped behind routines.

Completeness4/5

The domain is very broadly covered: audits, tracking, experiments, SEO, ASO, ads, outreach, launches, content, payments, and verification all have lifecycle operations. There are minor gaps and many specialized workflows, but an agent can find a path for most growth tasks.

Available Tools

136 tools
accessThe latest access auditB
Read-only
Inspect

The latest stored access audit: every area with its status, what was seen and the fix. Free.

Inputs: no named parameters.

ad_anglesAd angles from peers' adsAInspect

Before a boost's ads are written: what products a step ahead run now, and what their buyers complain about. For up to 6 peers (the latest peer study's, the ones the founder named, the brief's competitors, or the ones you pass): their Meta ads (Meta Ad Library), LinkedIn ads, Google ads (Ads Transparency: how long each ran; their words are in an image, open the link to read one) and Trustpilot reviews of 3 stars or fewer (an app's 1 and 2 star App Store reviews instead); TikTok Creative Center's top ads for up to 2 buyer searches; and, free, the Reddit and X posts the latest feature ideas study read. sources come numbered S1, S2..., ads with words and the longest running first: an ad that has run for months is the signal it pays. A read under 14 days old comes back free unless refresh (or new peers or searches). With angles (5 to 8, each a hook in the buyer's words and the source it came from), it keeps them instead, free: the ads and the video cuts are written from them, boost_plan takes each ad's angle, and the daily check copies a winner with one not used yet. A study of peers, read once when asked: never a watch. Costs $0.09 from the balance, charged only when it returns. About 26 treg calls at $0.001 to $0.0019 each; nothing is charged when nothing comes back.

Inputs: peers, angles, refresh, searches.

ads_proposePropose Apple Ads keywordsAInspect

Propose new exact keywords to bid on (from keyword_research, the App Store keyword field or the reviews) or negatives, for the founder to approve in the results app. Each needs its campaign and ad group (from ads_review) and why. Nothing changes in Apple Ads before the founder approves. Growth. Free.

Inputs: items (required).

ads_reviewReview Apple AdsAInspect

Read the founder's Apple Ads for the last days (campaigns, keywords, search terms: taps, installs, spend, cost per install) and propose changes with the numbers behind each: exact keywords for search terms that install, negatives for terms that spend with no installs, bid moves toward the target, pauses, more budget where a campaign is capped at a good cost. With the app's vendor number saved it also reads what came after the install (trials, offers and subscriptions started, from App Store Connect): afterInstall gives the share of downloads that start one and the estimated cost per start, the target can be a cost per trial (targetCostPerStart), and when not one started after enough installs no bid goes up, no budget grows and each campaign that still spends gets a pause proposal; a campaign paused that way gets a resume proposal once starts come. With starts, a campaign's countries whose downloads start nothing while the app's rate expects some get a proposal to stop showing there. Apple never ties a start to a keyword, so keywords and search terms are judged by installs. structure: where the account differs from Apple's campaign structure (brand, category and competitor on exact match with Search Match off, one discovery campaign with the others' exact keywords as negatives, new users only, iPad apart), for the founder to change in Apple Ads. Proposals wait for the founder's approval on the App Store page of the results app; nothing changes in Apple Ads before. Growth. Free.

Inputs: days, targetCpi, targetCostPerStart.

ads_setupAd account and trackingBInspect

Where an ad platform (x, meta, reddit, tiktok or google) stands for a boost, in the fixed order: 1. account (an ad account with a payment method the founder added, read in their browser; on Meta first a business portfolio and the Facebook Page the ads run under, with its own profile picture), 2. tracking (the platform's pixel on the site, loaded by Shipfound's script, so the founder deploys nothing: the pixel id and an event per ladder step, read in Events manager), 3. launch. Returns each step's state and what to do, what the campaign can optimise for, the recommended step of the ladder (landing page view, signup, payment: the deepest with enough volume) for the founder to confirm, the site's signup and payment goals (firable: whether the pixel can see them in the browser), and clicksSeen: visits in the last 7 days that arrived with the platform's click id. appTraffic: TikTok for an iOS app, run as traffic to the App Store link with no pixel (TikTok's app events need its SDK or a measurement partner). intent: whether a Google search test comes before a cold feed test for this product (a phone cannot take its first step, or nobody has paid yet), why in one plain line, and terms, the searches it starts from (a rival's "alternative" search, the buyer's problem, searches the site already shows for). With record, first stores what you read: account { adAccountId?, name?, payment?, currency?, businessId?, pageId?, pageName?, pagePicture? } (X: ads.x.com; Meta: business.facebook.com settings and Ads Manager; Reddit: ads.reddit.com; TikTok: the advertiser id, aadvid= in ads.tiktok.com's URL; Google: the customer ID at ads.google.com); tracking { pixelId, events?, verified? } from Events manager (X: the pixel id and each event's id; Meta: the dataset id; Reddit: the pixel id, a2_ or t2_; TikTok: the TikTok Pixel's id; their standard events need no ids; Google: the conversion ID, AW- and digits, as pixelId, and each conversion action's label, after the slash in its send_to, as the event; verified: it shows events recorded from the site, or on Google the tag shows as active). Free.

Inputs: record, platform.

agent_insideAgent InsideCInspect

Agent Inside™: the product as a tool the agents people use can call, and inside the skill packs, agent templates and automation nodes they install. Returns which of the product's own surfaces shipped (skill, mcp server, automation node), the targets found in others' repos (a pack, a template, a node or a list; how each takes an addition: pr, issue or email; its status: found, opened, emailed, merged, declined) each with its tagged link, and the rules. add: targets the agent found (kind, name, url, owner, stars, how, note), one per repo. mark: one step for one target by its key or url (opened with prUrl, the PR or issue the founder opened; emailed; merged, recorded as a listing with its campaign so what it brings is read; declined; skip). Free.

Inputs: add, mark.

ai_offerAI Agent OfferAInspect

AI Agent Offer: one offer for the people ChatGPT, Claude and Perplexity send, said the same to people and agents. With nothing: the AI-sent visits of the last 28 days by engine with their conversions, whether a landing line is worth testing yet (10 AI-sent visits in 28 days), the founder's offer if kept, whether one shipped, referralScript (a browser expression naming the assistant that sent the visit, or null), the offer page's Markdown and its schema.org Offer once the offer is set, and the rules (never content for bots only). With save: the founder's offer (kind credit, discount, trial or other; what they get, in their words; apply auto or code; the code; an end date). Free.

Inputs: save.

analyticsAnalyticsA
Read-only
Inspect

Run any report on the site's traffic: overview, realtime, channels, ai_search, sources, landing_pages, pages, shipped_work, ai_crawlers, conversions, errors, timeseries, funnels, page_flow, users, user. AI Search is its own channel, broken out per engine, and shipped work is a dimension. users: the people the product's own server reports (POST /t/u, routines/users.md): signups, activation (the users_activation rule), active and paying people, weekly cohorts, and each person with what they did and where they came from; user (with user): one person's timeline. Default period: the last 28 days. Free.

Inputs: report (required), to, from, user, +6 more.

app_addAdd an iOS appAInspect

Add the founder's iOS app to this workspace from its App Store link (apps.apple.com/.../id123). Reads the public listing: name, subtitle, rating, reviews count, languages, screenshots. Free.

Inputs: url (required).

app_auditApp Store listing auditA
Read-only
Inspect

Check an app's App Store metadata against the ASO rules: character limits, wasted keyword characters, words repeated across name, subtitle and keywords, the locales its storefront indexes (keywords are not combined across locales), screenshot captions, and whether the description works for AI answers. Pass locales from the repo's fastlane/metadata// files (name.txt, subtitle.txt, keywords.txt, promotional_text.txt, description.txt) for the full check; without them only the public listing is checked, and the keyword field is private. Free; the fixes are yours to write, as a PR.

Inputs: appId, locales, storefront.

app_countriesWhich country to open next on the App StoreAInspect

The countries the app's listing could open next, best first: first-time downloads from a country whose language the listing does not have yet (from App Store Connect, when connected with the Admin role), then countries where a keyword check found open searches, then large stores to check first. For each: the App Store Connect locale to write and its language. Pass locales from the repo's fastlane/metadata// folders when App Store Connect is not connected; without either, the listing counts as written in its storefront's language only. Free; the latest read is kept for grow.

Inputs: appId, locales.

app_cpp_createMake a custom product pageAInspect

Make a custom product page as a draft for one audience or search: its promotional text, a deep link, the search keywords it should show for (only words already in the approved keyword field can be assigned; Apple shows it in search once approved), and new captioned screenshots. It starts from the live version's media. Link a shipfound.site page to it with ppid (app_site). The founder submits it for review in App Store Connect. Growth. Free.

Inputs: name (required), appId, locale, deepLink, +3 more.

app_cpp_listList custom product pagesB
Read-only
Inspect

The app's custom product pages in App Store Connect, each with its ppid to link from a shipfound.site page (app_site) or an Apple Ads ad group. Free.

Inputs: appId.

app_downloadsDownloads and trialsB
Read-only
Inspect

First-time downloads and redownloads for the last days, by source and country (App Store search, browse, web referrer, app referrer) and by campaign (the sf-* campaigns are the app's shipfound.site pages), from App Store Connect's analytics reports (the key needs the Admin role; Apple makes the first report a day or two after connecting). With the vendor number saved, also what came after the download, from Apple's subscription event report, whatever the app uses for subscriptions: free trials, paid offers and subscriptions started, and trials that became paid, with startRate (starts per first-time download). And productPage: how often the app was seen in a list, its product page views, and Get taps, with pageRate (Gets on the page per page view). Free.

Inputs: days, appId.

app_event_createDraft an in-app eventAInspect

An in-app event as a draft in App Store Connect: a card in search results and on the product page for something time-bound in the app (a challenge, a new season, a big update). Text per language: name (30), short description (50), long description (120). It lasts at most 31 days and shows from up to 14 days before. Its card and page images are added by the founder in App Store Connect, who then submits it. Growth. Free.

Inputs: badge (required), purpose (required), eventEnd (required), eventStart (required), +7 more.

app_eventsIn-app eventsB
Read-only
Inspect

The app's in-app events in App Store Connect, newest first: name, badge, state and dates. Free.

Inputs: appId.

app_experiment_createSet up an App Store A/B testAInspect

Set up a product page test as a draft: up to 3 treatments, each a set of new captioned screenshots, against the current product page, for a share of visitors (trafficProportion, percent). Apple tests the icon, screenshots and previews only, not text, for up to 90 days. The founder starts it from the results app (or App Store Connect); never say it is running before they do. Growth. Free.

Inputs: name (required), treatments (required), appId, locale, +1 more.

app_experiment_listList App Store A/B testsC
Read-only
Inspect

The app's product page tests in App Store Connect. Results are in App Store Connect (Product Page Optimization). Free.

Inputs: appId.

app_featuringFeaturing readiness and momentsB
Read-only
Inspect

Before a featuring nomination: Apple's own factors for featuring, each with what the public listing shows and what to check in the app's repo; the dated moments ahead that suit the app's category, with the last day to nominate; and the nominations and in-app events already in App Store Connect. Awards take no applications. Free.

Inputs: appId.

app_keywordsApp Store searches the app can winAInspect

Check App Store searches in one country, as the App Store shows them: where the app ranks on the first page, whether Apple suggests the search as people type it (Apple publishes no volumes; a suggested search is one people make), how many of the top 10 put its words in their name or subtitle, and how many ratings the top 5 have. Each search gets a verdict: open (few of the top 10 name it and they are small), gap (few name it, big apps), weak (many name it, small apps), crowded, thin (under 5 apps answer it), brand (one app's name), or yours (the app is in the top 10). Pass 3 to 10 searches in that country's language, from the listing, the repo and the reviews' own words; with expand (default) Apple's longer suggestions for each are added, up to 20 in all. Free; the latest check per country is kept for grow.

Inputs: searches (required), appId, expand, country.

app_metadataApp Store Connect metadataA
Read-only
Inspect

Every locale's name, subtitle, keyword field, promotional text, description and what's new, read from App Store Connect: the version being prepared (if any) and the live one. Needs the founder's App Store Connect key (connected on the App Store page of the results app); without it, use app_audit with the repo's fastlane metadata. Free.

Inputs: appId.

app_metadata_stageStage listing changesA
Destructive
Inspect

Write listing changes into the version the founder will submit, through App Store Connect: name and subtitle (30), keyword field (100), promotional text (170), description (4000), what's new; new locales are added. Never touches the live listing, never submits. Show the founder the exact text first. Builder and Growth. Free. Afterwards the founder submits the version for review in App Store Connect; once it is out, record_action module ASO, kind STORE_LISTING, meta.appStoreId and expect.. for each change, then verify.

Inputs: changes (required), appId.

app_nomination_createDraft a featuring nominationAInspect

A featuring nomination as a draft in App Store Connect: asks Apple's editors to consider the app for featuring around a date, for a launch, an update or new content. Apple asks for at least two weeks' notice and up to three months for wider consideration. The description is written to an editor: what is new, for whom, why it matters to them, and who made it and why, plainly, with no superlatives. Link the in-app event it is about. The founder submits it (App Store Connect, Featuring, Nominations). Growth. Free.

Inputs: name (required), type (required), description (required), publishStartDate (required), +11 more.

app_pricesSubscription prices by countryAInspect

Propose a lower subscription price in the countries the app's first-time downloads come from (and those whose listing opened), from the World Bank's price level there (local prices against US prices for the same things), snapped to Apple's price points. Only decreases, never below 40% of today's price, never where the price is already under the US price at the exchange rate. Each proposal waits for the founder's Approve on the App Store page of the results app; nothing changes before. Apple has no price A/B test: each change is read per country before and after. Growth. Free.

Inputs: appId.

app_purchasesIn-app purchase namesBInspect

The app's in-app purchases and subscriptions from App Store Connect, each with its display name and description per language, and what to change: names made only of plan words ("Premium", "Pro Yearly") carry nothing people search for, names that miss every search the app aims at, and listing languages a purchase has no name in. ASO tools see the display names count in App Store search (Apple has not documented it); they show on the product page. Free; the read is kept for grow.

Inputs: appId.

app_purchases_stageRename in-app purchasesA
Destructive
Inspect

Write in-app purchase and subscription display names (2 to 30 characters) and descriptions (up to 45) per language in App Store Connect: a language the purchase has is changed, a new one needs both. Apple reviews them with the next submission; nothing shows before then. Show the founder the exact text first. Builder and Growth. Free.

Inputs: changes (required), appId.

app_ranksWhere the app ranks in App Store search, week by weekAInspect

The app's place on the first page of App Store search for the searches its keyword checks track (open, gap, weak, and the ones it holds), per country, from the first read to the latest. Shipfound reads them every week; refresh reads a country now, at most once a day. A rank past the first page (about 11 apps) is null. Free.

Inputs: appId, country, refresh.

app_reviewsApp Store reviewsB
Read-only
Inspect

The app's latest App Store reviews from Apple's public feed: star counts, rating by version, the share of 1 and 2 star reviews, and the low reviews themselves for you to group into the to-do list (what to fix, what to answer). Free.

Inputs: appId, pages, country.

app_screenshotsScreenshots with captionsAInspect

New App Store screenshots: a caption (and an optional second line) over each raw screen, rendered at the exact size App Store Connect takes, in any script (Japanese, Korean, Arabic...). proof: "rating" adds the app's own rating under the caption, from its listing. Returns a link per image to show the founder or download. Write captions as benefits in the words people search: since 2025 caption text appears to count for App Store search, and the first three screenshots carry the search result and the product page. app_experiment_create and app_cpp_create upload them for you; app_screenshots_apply puts a set in the next version. Free.

Inputs: screenshots (required), size, appId.

app_screenshots_applyPut screenshots in the next versionA
Destructive
Inspect

Put a set of captioned screenshots, in this order, into the version the founder will submit, for one language and size: the winning treatment of an A/B test, or the screenshots of a language just opened. It replaces that size's screenshots in that version; nothing live changes until the founder submits and Apple releases it. A change to the screenshots everyone sees is tested first (app_experiment_create): apply a set without a test only for a language that has none of its own. Builder and Growth. Free.

Inputs: why (required), locale (required), screenshots (required), size, +1 more.

app_siteThe app's own siteA
Destructive
Inspect

Read or write the app's small site on .shipfound.site: a home page and up to 11 pages, one per search people make ("budget app for couples"), each with a title, description, headline, intro, sections and FAQs, linking to the App Store or to a custom product page (ppid). Most apps have no website, so this is what Google and AI answers can find and cite. Pick each page's search with keyword_research; write from the listing, the repo and the reviews, never invented numbers or quotes. Without content it returns the current draft and its issues. Writing the draft is free; publishing is the founder's own action in the results app (Builder and Growth). Never tell the founder it is live before they publish.

Inputs: slug, appId, content.

aso_setThis week's App Store listing workB
Read-only
Inspect

The week's set for the first app, picked from the stored listing check (app_audit), the App Store search checks per country (app_keywords), the ranks (app_ranks) and the country read (app_countries), so the founder does not choose item by item: the listing check or its open fixes, the search check when it is missing or a month old, the name, subtitle and keyword field aimed at the searches the app can win in each language the listing has, the next country to open, and the first open finding of the study of apps a step ahead (kind study: its key, the aso part its command names, and the Research tab's link). A language whose listing changed in the last two weeks waits (held), so a change is read on its ranks before the same words change again. Each action says its routine part and what to record (record_action meta), so the week's set counts as done. Also what moved in App Store search. Free.

Inputs: no named parameters.

assets_saveSave files to the Assets tabAInspect

Keep a copy of the files you made for the founder (boost ad videos and images, Shorts slides, UGC videos, voice tracks, video kit renders) in the results app's Assets tab, where they can watch and download them on any device. After the files are on the Desktop: call it with files (each file's name, kind, source and size in bytes; mp4, mov, png, jpg, jpeg, webp, mp3, wav, m4a; up to 200 MB each; up to 20 a call), upload each with the curl it returns, then call it again with confirm and the ids. Never blocks the hand-over: when it fails, the Desktop folder is the hand-over. Free.

Inputs: files, confirm.

bing_connectConnect Bing Webmaster ToolsAInspect

Store the founder's Bing Webmaster API key (Bing Webmaster Tools, Settings, API access), encrypted, so Shipfound can read which of the site's pages Bing has and send it pages through Bing's API. Checks the key against Bing and that the site is verified in that account. The founder gives the key; never type it into a page for them. Free.

Inputs: apiKey (required).

bing_submitSend pages to BingAInspect

Send pages on the site to Bing through its API, within the daily quota Bing gives the site, and the sitemap when given. Only after the founder's yes on the list. Returns the pages sent and those past today's quota, for tomorrow. Needs bing_connect first. Free.

Inputs: urls (required), sitemap.

boost_candidatesPosts worth boostingA
Read-only
Inspect

The founder's original X posts from the last 30 days, minus any boosted before (or saying what a boosted post said; those are listed in boosted), ranked for a boost: likely site visits and signups in the 48 hours after each (when it links to the site), and engagement against their usual. Posts with under 500 views are marked untested, not weak: the boost is the test. Whether a post is about the product and makes sense to a stranger is your call. Only when the founder asks which post to boost; a post they name goes straight to boost_plan. Free.

Inputs: handle.

boost_changeRecord a change to a running boostAInspect

Record a change the founder made in Ads Manager on their yes, or one they turned down, on a running boost: pause (an ad group), budget (an ad group's new budget, toUsd), duplicate (a copy of ad n with a new hook and its budget, toUsd; it becomes a new ad with its own tagged link, read like the others). The caps are checked again whatever the proposal said: +20% at most a step, a copy at most 20% of the approved total, and the ad groups never committing more than the approved total; refused otherwise. Record it after the founder saved it, never before. The final read compares the boost with its plan, changes included. Free.

Inputs: n (required), id (required), kind (required), status (required), +5 more.

boost_checkCheck a running boost's adsA
Read-only
Inspect

The daily check while a boost runs, after its numbers are recorded today (boost_record): each ad group's spend, impressions, link clicks and, past the click, visits, signups and cost per signup, and the changes to put to the founder. pause: an ad group that spent past its threshold with no signup (2x the plan's expected cost per signup, at least $5 and at most 75% of its budget; half its budget when the plan could not price a signup). budget: more for the ad group with the cheapest signups, at most +20% a step, once a day. duplicate: that winner copied with a new hook from ad_angles, at most 20% of the approved total, up to 2 a boost (not on Google). Each draws only on what pauses free and the approved total leaves (caps). Proposals made or turned down before are not put again. Proposes only: the founder approves each and makes it in Ads Manager. Free.

Inputs: id.

boost_planPlan a boostAInspect

Plan a boost: on X (default) one to three of the founder's own posts; on Google (platform google) one to three search ads, each with its own keywords (the searches it answers), headlines (3 to 15, up to 30 characters) and descriptions (2 to 4, up to 90), only with searchVolumes from keyword_research showing people search for them; on Meta (platform meta) one to three ads written for it, each a primary text and a headline over the product video; on Reddit (platform reddit) one to three ads written for it, each a headline (up to 300 characters) over the product video, or with format post a text-only ad that reads like a post: a title (text, up to 300 characters) and a body, with comments on, on the Traffic objective optimised for clicks (Reddit offers text post ads no Sales objective, so no optimize) and with no destination URL: the tagged link is the body's last line, in brief.copy per ad group; on TikTok (platform tiktok) one to three ads written for it, each an ad text (up to 100 characters) over the 9:16 product video, aiGenerated saying whether the video shows an AI presenter or AI-made footage (TikTok's "AI-generated content" switch), every device (TikTok runs in its phone app only), at least $20 a day per ad group; an iOS app on TikTok (ads_setup appTraffic) runs as traffic to its App Store link with no optimize, each link tagged ct. An equal budget per post or ad (default $45, at most $300), the days, a tagged link per post so each visit and signup traces to it, what to expect and the stop rule. A post the founder named goes in as is: no data is read about it. Goal visits (default) runs each post as a Promoted-only copy with its link; reach boosts the post itself. targeting is who sees it, as the founder answered: locations, and optionally languages, gender, age, follower look-alikes, keywords, interests, and on Reddit communities (Meta: no look-alikes or keywords; Reddit: no look-alikes). Refused until ads_setup says the ad account and tracking are done on that platform. optimize is the step of the ladder the founder confirmed; a step with too few a week for the platform to learn from is refused (it bids high for the few people it guesses) unless force is true, which only the founder's own say-so after hearing that allows. posts[].media names the files you upload for each ad (cut and format), else the ad's files by name in the ads folder on the Desktop. refreshOf replaces a running boost whose creative or setup is weak: its messages are not offered again, and the plan returns what is left of its budget. firstStep (once per product, kept): whether a phone can take the product's first step, as you found it and the founder confirmed; without one on file a visits plan is refused. devices: every device, desktop only, or split (each ad twice, desktop only and phones only, half its budget each), as the founder confirmed; default from the first step (split when a phone cannot take it), returned as devices with the why. sizing says what each question costs: clicks (enough impressions to compare click rates) and signups (about 5 signups per ad group at the site's own rate, or why it cannot be priced), and what this budget answers; question sets the budget to the one the founder picked. landing: the A/B test of each ad's own line as the landing page's headline, only for the boost's visits (key, name, hypothesis, path, goal for experiment_create, and the gated page code for a PR). retargetOf plans the optional second phase: a small ad to an earlier boost's visitors who did not sign up (default $20 over 5 days, desktop only when a phone cannot take the first step; the audience is created first, in the setup). Returns the Ads Manager setup, the checks for the Review page, and brief.warnings: what is wrong with the audience for this message. intent: whether a Google search test should come first (a phone cannot take the first step, or nobody has paid yet), with why. capture: on X, Meta and Reddit when a phone cannot take the first step, the A/B test that offers the boost's phone visits the setup link by email (goal setup_link, saved first; the code for a PR; where the emails go; the signup follow-up hand-off); the landing test then takes the computers only. Nothing is launched or spent. Free.

Inputs: posts (required), days, goal, force, +14 more.

boost_recordRecord a boost's numbersAInspect

Record what the platform's Ads Manager shows for a boost, read in the founder's Chrome: per post or ad (n, the ad group's or ad set's number in the plan; a split boost per ad group, with device desktop or phone) the spend in USD (an account billing in another currency: converted at today's rate), impressions, and link clicks, not all clicks (engagements for a reach boost). status running when the founder has pressed Launch or Publish, stopped when they stop it. Reddit and Google, where your browser cannot go, or a TikTok export: pass the founder's export as csv (Reddit Ads, Reports, by ad group, Export; TikTok Ads Manager, the campaign's Ad group tab, Export, with Cost, Impressions and Clicks (destination); Google Ads, Campaigns, Download) and the server reads each ad group named "ad ", or Google campaign named sf-boost-- (spend or cost, impressions, clicks; daily rows added up), with usdRate when the account bills in another currency; numbers in posts win over it. Never invent a number: leave out what you could not read. Free.

Inputs: id (required), csv, posts, status, +2 more.

boost_resultsRead a boostA
Read-only
Inspect

A boost against its stop rule and, with several posts, against each other: each post's click rate, cost per click, cpmUsd (cost per 1,000 impressions), and the visits and signups its tagged link brought; costAlarm when an ad pays over twice the top of the platform's CPM range after $10, with the likely setup causes; taggingNote when the platform shows clicks but few or no visits carry the boost's tags; the verdict (not launched, needs numbers, too early, stop, winner, no clear winner, working, lost after click: people clicked and none signed up). A winner is called only at a 90% chance of being the best, once each post has 1,500 impressions; on signups once there are 5, else on clicks. path: the visits past the click (stayed, reached the signup page, signed up, paid), by phone and desktop, against the site's usual engaged rate; diagnosis: the step that lost people (message, page, device, signup, or holding) and its next move; devicesNote: a split boost's desktop and phone ad groups side by side; retarget: whether enough visits did not sign up to offer the optional retargeting ad (the platform's minimum audience over the half its pixel matches: 200 visits on X and Meta, 2,000 on Reddit and Google), which then comes before a new cold test; clickStop: 150 ad clicks or more and nobody through the conversion step (a signup, or the phone capture's email), so stop and fix the page or the audience, never a refresh. Without id, the latest boost. With history true, instead every boost launched before: its posts' links and words, where it went and its verdict, so a new boost tests something new. Free.

Inputs: id, history.

brain_reviewReview the brain (Shipfound admins)A
Destructive
Inspect

For Shipfound's own admins only; anyone else gets a refusal. Lists the candidate rules waiting for approval (with the lessons behind them), the live rules with how often they failed to prevent a repeat and how many founders disputed them, and the results pool: what each kind of move brought across founders this week against four weeks before. With approve, reject, retire or edit it applies those decisions first. Free.

Inputs: edit, reject, retire, approve.

build_ideasFree tool or skill ideasAInspect

Ideas for something the founder gives away that brings buyers back to the product. kind tool: free tools for their site (checker, generator, calculator) their buyers search for, each with the keyword, its monthly searches, what it takes and returns, and how the result leads to the product; Costs $0.05 from the balance, charged only when it returns. Nothing is charged when it comes back empty. kind skill: agent skills for the product (name, the SKILL.md description, how it uses the product), whether a skill fits this product, and the skill directories left to list it on. Free. What is built already is left out.

Inputs: kind (required).

bullseye_addAdd people to a Bullseye TestAInspect

Add people to a Bullseye Test™'s list, up to 200 a call: each one who said in public that they have the problem, with the channel that reaches them. email: an address they published or one that checked out (never guessed, never catch-all). x_dm: only when their X inbox is open (checked in the founder's Chrome; a closed inbox is not counted as reached). reddit_dm: their Reddit username. opener: one line written from their own post, the first line of their message. Each person is kept once across every test, and nobody outbound already wrote to (by handle or address) is added. Free.

Inputs: people (required), id.

bullseye_batchToday's Bullseye batchC
Read-only
Inspect

Today's people for a Bullseye Test™, per channel, newest post first, within each channel's 20 a day (email also within the hard line's 20 drafts a day, every mode counted) and the test's size; with each channel's tagged link, which every message carries as it is. Free.

Inputs: id.

bullseye_changeGrow or stop a Bullseye TestAInspect

Grow a running Bullseye Test™ by a third of its size after a too-close read (extend), or stop it (stop), each on the founder's yes. Free.

Inputs: change (required), id.

bullseye_markMark Bullseye messages sent or skippedAInspect

Record which of today's Bullseye Test™ people got their message (reached: the founder sent it, or an email's draft is saved for them to send) and which could not be reached (skipped, with why: a closed inbox, no address, the founder passed). The first reached locks the bet. A reached email also counts toward the drafts a day. Free.

Inputs: marks (required), id.

bullseye_planPlan a Bullseye TestAInspect

Plan a Bullseye Test™: the founder's bet as "At least X% of Y will Z", sized by Shipfound into how many people must get a personal message and the lines a result must cross (pass, and fail once everyone has had their 7 days; between them it is too close to call and grows by a third). rate is X, set by the founder. who is Y in words (people who said in public they have the problem). outcome is Z: a goal the site's tracking fires (kind goal, its name from goals_list) or an event the product's server sends for a user (kind event, the users routine). A planned test changes until its first message goes out; then the bet and the lines are locked. Free.

Inputs: who (required), rate (required), outcome (required), days.

bullseye_readRead a Bullseye TestBInspect

A Bullseye Test™'s read: reached per channel, the visits its links brought, how many did Z, and the verdict against the lines locked at the first message: pass (as soon as the hits cross the pass line), fail or too close (only once everyone is reached and their days are up), or still running. A pass or a fail closes the test. Free.

Inputs: id.

check_contentCheck a draftAInspect

Run the gates on a local draft before the PR: fabrication (numbers with no source), unsupported claims, disparagement of other products, duplication, placeholders left in, banned machine-sounding words, dashes, answer-first opening, headings, length and links. Pass the facts content_brief returned. Free.

Inputs: type (required), markdown (required), facts, title.

content_briefContent briefAInspect

The research for one page: facts with their source URLs (read from the pages that rank and the pages AI engines cite), the headings those pages cover, People Also Ask, the gaps none of them answers, an outline, and the rules the page is checked against. You write the page in the repo from this; every number must come from a fact. Costs $0.10 from the balance, charged only when it returns.

Inputs: type (required), topic (required), keyword.

convert_pagesThe pages that bring visitors, read for a way to sign upBInspect

Read the pages visitors land on most beyond the home page (articles, answers, comparisons; the founder's tracking, 28 days): links to signup, pricing, checkout or the app in the page's own content versus only in the header, and how many of those landings signed up, against the pages' average. Also the signup form's visible fields. A missing way on ships as an A/B test (experiment_create), never as a straight change. Free; kept for grow.

Inputs: no named parameters.

customers_broughtPaying customers Shipfound broughtC
Read-only
Inspect

Revenue share: each paying customer of the product, from its payment provider (read hourly), whether Shipfound brought them and through which shipped work (a page, a listing or post, a tagged link, an ad it made), or why not (another way, the founder's own ads, a customer before, more than 90 days after the visit), what they paid and the share; this month's share charged, owed and the cap; and why paid jobs wait, when a share cannot be charged. Free.

Inputs: no named parameters.

drop_threads_findFind drop threads and write a reply to eachAInspect

Threads and posts that invite founders to share what they built ("drop your startup below", "what are you building", "let's get 10 people to try your app"), for one platform: reddit, open threads from the last two weeks in the communities where makers share and across Reddit, busiest and freshest first; x, posts from the last three days. Only posts that themselves ask for products are kept, so the reply names the product as the founder's own, with its address, and answers each thing the post asks; what a post asks in return (trying another builder's app) is in the draft's why, for the founder to do themselves. One reply each, up to 5; never a thread with a draft or a recorded reply already, never the founder's own post. The same run as reach_find, on Assisted posts, marked Drop thread. Runs in the background, about two minutes. Costs $1.40, charged only when it writes drafts: tell the founder the price and wait for a yes. Returns the link to the drafts. Nothing is posted.

Inputs: platform (required).

experiment_closeStop an A/B testA
Destructive
Inspect

Stop a test and record the variant kept (the winner, or the control when nothing won). Then ship the kept variant as the page's only version, remove the experiment code in the same PR, and record_action it with module EXPERIMENTS. Free.

Inputs: key (required), keep (required), note, site.

experiment_createStart an A/B testAInspect

Size and start an A/B test on one page against one goal. Every visit is in the test, in either tracking mode: a visitor without a stable id is assigned by the visit, with nothing stored. Reads the page's last 28 days, works out the visitors each variant needs to detect the lift (mde, default 0.2 = 20%) and how many weeks that takes. A quiet page is never refused: a slow test starts all the same, with the numbers, and reads not enough yet until it has an answer. On success it returns the code to put on the page (Next.js with @shipfound/next, or plain HTML with sf.variant), which you ship as a PR. The control is the first variant. Free.

Inputs: key (required), goal (required), name (required), path (required), +4 more.

experiment_resultsRead an A/B testA
Read-only
Inspect

Visitors exposed and converted per variant (a conversion counts only at or after the visitor's first exposure), each variant's rate with its 95% interval, chance to beat the control, the lift and its interval, a sample ratio check, and the verdict: keep running, winner, control wins, no difference, or a broken split. Never call a winner the verdict does not. Without a key, every test in the workspace, running first. Free.

Inputs: key, site.

followup_offerWhat to offer signups who got stuckA
Destructive
Inspect

What the founder offers in each note to a signup who got stuck, kept once per product and changed any time: call (a 10-minute call, with their booking link when they have one), setup (they set it up for the person, or do their first result), question (one question: what were you trying to do?), credits (amount, in unit, for the person's feedback, to at most cap people) or own (text, the offer in their words). Without kind, reads it. Free.

Inputs: cap, kind, link, text, +2 more.

followup_targetsSignups who got stuckAInspect

People to write one personal note to, from the product's own users report (routines/users.md): signed up in the last 14 days, nothing paid, quiet for 2 days, and not activated or stopped after one go. Those who did something before they stopped come first, then those from a channel nobody paid for. Never the founder's own or a test account (the product's domain, the team's addresses, the sending address), anyone an inbox draft already went to, or anyone skipped. For each: person (the product's own id), email, name, did (what they did, in plain words), from (their first channel), and record (what record_action takes once the draft is made, as it is). Also the offer (followup_offer) and its cost for credits, the founder's voice (notes_voice), sender (mail_setup) and draftsLeftToday (the 20 inbox drafts a day, counted on the server; a batch is never bigger). skip: people the founder will not write to, never offered again. Free.

Inputs: skip, count.

funnel_checkHome page and signup path checkAInspect

Whether a visitor understands the page, wants the product, and can get from the home page to signup and payment. Reads the live home page from outside and follows every button near the top: one that only scrolls the same page, a broken link, no signup within one click, a signup page with no form or sign in with button, a pricing page with no way to start or pay. Returns those misses (fail, or unsure when script decides), each with evidence, a fix and an id for meta.fixIds; funnel: the site's mapped funnels (funnels_save) with visitors at each step and leak, the move between two steps that loses the most visitors across them and what kind of move it is (mapped false until the agent maps them; then only 28 days of visitors, signups and payments); plays: what to try on that leak, best evidence first, never one that needs proof (testimonials, logos, user counts) the business may not have, nor one already shipped or skipped; judge: whether an A/B test can answer at this traffic or the change ships as a before and after on the same move; read: the page's words, the founder's list of what the product gets its customers (null until they give it once), and a script that measures the page at phone width; and walk: the checks only a browser can make (mobile-cta, after-signup, upgrade-path), for the agent to walk in the founder's Chrome without creating an account or paying. Call again with record for what the read and the walk found (copy checks: copy-understood, copy-value, copy-filler, copy-cut, copy-length, copy-missing, copy-visual; a miss about particular lines quotes them word for word, and lines not on the live page are refused), measure for the phone numbers before and after, outcomes for the founder's list, or skip for ids the founder will not fix. A shipped fix is hidden until the site is read again after it, and verify re-checks it on the live site: the buttons, and that the lines a copy fix changes are gone. Free.

Inputs: url, skip, record, measure, +1 more.

funnels_saveSave a funnelA
Destructive
Inspect

Save a funnel you mapped from the site's code: the path most visitors take toward signing up or paying from one of the most visited pages (find those with analytics page_flow: the top pages, where visitors go next, what they click). Each step is a goal's definition: PAGEVIEW (a path, * for a wildcard), EVENT (an event name, or name@/path such as form_submit@/register, which t.js sends with no code on the site), CTA (the element's data-sf value, * for a wildcard), ENGAGED, REVENUE (trial, paid) or CHECKOUT (a visit back from a hosted checkout). Put other ways that count as the same step in any, and where you found each step in evidence (file:line). Steps count in order (strict, the default) within windowDays (default 7). The same name redefines a funnel; remove: true deletes it. It is counted from events already stored, so it returns its last 28 days at once: a step no one reached is usually a wrong pattern. Free.

Inputs: name (required), steps, remove, siteId, +2 more.

giveaway_markOne giveaway replyAInspect

One step for one person who replied (key from giveaway_replies): draft (the founder picked them: the public reply with their result, checked: on X no link and no pitch, never a review asked for; returns X's reply box filled in, or the Reddit comment to answer), posted (the founder posted it; url is their reply's link), skip; or close the giveaway. The founder can pick anyone who replied, in any order; a drafted or posted reply is a pick and counts against the cap. Only a pick unlocks a drop's credit: nobody can claim before. Everyone posted to is kept for the signup follow-up. Free.

Inputs: action (required), key, url, site, +1 more.

giveaway_planGiveaway Drop: what to proposeBInspect

What a Giveaway Drop™ starts from: the product (what it does, its buyers and their pains, from the brief), its feature ideas and peer study patterns when there are any, where it can post (X and Reddit, by the audit), the subreddits that take a founder's post with their rules, any giveaway running (replies, waiting, delivered), the four shapes (a result done for each person, capped credits or usage, an asset, founding seats) with how each is delivered (credit by match: it lands when they sign up with what they listed), a cost line per shape at the default cap of 10, and the rules every giveaway keeps. unitCostUsd: what one use of the product costs the founder when it pays AI or API costs per use, asked once and kept. Free.

Inputs: unitCostUsd.

giveaway_repliesRead the giveaway's repliesAInspect

Read the replies to the running giveaway's posts (X: the post's conversation; Reddit: the post's comments), minus the founder's own, one per person, and keep them. Returns the queue: who to offer the founder next, in reply order up to what is left of the cap (the founder can pick anyone who replied; nobody can claim before a pick), each with a key, what they wrote (their URL or what they need), the link they gave and the product it names (host, the claim key of a match drop); and the counts so far, claimed included. Read again later for new replies; do not loop. Free.

Inputs: no named parameters.

giveaway_startStart a Giveaway DropBInspect

Keep the Giveaway Drop™ the founder picked, with the cap and end date they set: shape (result, credits, asset, seats), what each person gets, who it is for, what to reply with (ask: "your startup's link", "your site's URL", "what you are stuck on"), cap (1 to 100), endsAt (within 30 days, or none), unitCostUsd when known. Credits or seats: claim code (one capped code each reply carries, the default) or match (credits only: it lands when they sign up with what they listed), and creditCents for credit in money per person ($30 = 3000). postUrls: posts the founder already put up for it ("comment below" posted first, defined here after), recorded as its posts. One at a time. Returns its source key for notes_save (the post goes out as a note, in its own slot), the cost line, a match drop's claimSecret for the founder's product (an env var, never the repo), and the tagged link (utm_campaign sf-giveaway-..., or an App Store campaign for an app) for the founder's profile, a Reddit body where the sub allows a link, or the asset page's button. Free.

Inputs: ask (required), cap (required), who (required), what (required), +6 more.

goals_listList goals and funnelsB
Read-only
Inspect

The site's goals (SOFT or HARD) and funnels. A payment goal is proposed automatically from the site's own data when goals are listed. Free.

Inputs: siteId.

goals_saveCreate or redefine a goalA
Destructive
Inspect

Create a goal, or redefine one with the same name: EVENT (an event name like signup, or name@/path for that event on one page: form_submit@/register is the signup form sent on /register, which t.js reports with no code on the site), PAGEVIEW (a path pattern like /welcome*), CTA (a data-sf value, * for a wildcard), ENGAGED, REVENUE (trial, paid), or CHECKOUT (a visit back from a hosted checkout such as Stripe or Dodo: a payment, seen without any code on the site; match is the return path pattern, * for any). Every goal you create is SOFT. Only the founder makes a goal HARD, in the results app, and the headline conversions count HARD goals once there are any; changing a HARD goal's definition puts it back to SOFT. Say why in note. stage puts it on the way to a payment: interest (clicks and pages before signing up, the signup page itself included), engaged, signup (a finished signup, each way of signing up is its own goal in this stage and the stage counts a session once), active (a signed-up person using the product), paying. Left out, it is read from the goal. Free.

Inputs: name (required), type (required), note, match, +3 more.

grow_answerThe founder's answer to a moveAInspect

Record yes or no to a move from today or record_action's next, by its key. A no rests the move for 7 days (30 after a second no), so it is not offered again tomorrow. For a yes, from says where the founder found it, so Shipfound learns how often the first five had what they wanted. seen: the moves shown on the next-five screen and not picked, which rest like the first screen's. said: what the founder typed in their own words instead of picking, word for word; Shipfound's ranking reads it as their direction from then on. Free.

Inputs: key (required), answer (required), from, said, +1 more.

grow_notesWhat Shipfound knows about this founderB
Read-only
Inspect

The notes grow's judge reads every day: the founder's own rules and facts (by founder: "no r/SaaS until Nov 10", "parents decide, not children", answers to grow's questions), what Shipfound learned from their picks and results (by shipfound), and today's open question if there is one. The founder edits them in the results app. Free.

Inputs: no named parameters.

grow_notes_saveKeep a note for growBInspect

Keep something the founder said that should hold from now on: a rule ("no paid ads this month"), a fact about the product or its buyers, or the answer to grow's question of the day (question: true closes it). One short line in plain words, theirs where you can. Grow's judge reads it every day; the founder sees and edits it in the results app. remove: a note's id, when the founder says it no longer holds. Free.

Inputs: text, remove, question.

ideasFeature ideas, latestB
Read-only
Inspect

The latest feature ideas study: what people on Reddit and X ask for around this product, grouped into features it could add. Each idea has the problem in their words, the feature, the smallest version to ship first, what the site shows on it today, the effort (small, medium, large), how many different people are behind it (2 at least), their posts (link, subreddit or handle, their own words checked on the post) and its key (IDEA:). kind missing: the product does not do it; unsaid: the site shows it does, yet people ask as if no tool did, so the move is to say it. Ideas done (recorded with meta.idea) or skipped with ideas_skip are left out. Also whether one is running, when the next free one is, and the price of one now. Free.

Inputs: no named parameters.

ideas_checkWhat the repo says about feature ideasAInspect

The ideas study reads only the site, so it cannot know what the product already does. After searching the founder's repo for each idea workspace listed in ideasToCheck (or any idea before offering it), pass what you found: built true with the file where it lives, and said true when the site already says it plainly; built false when the product does not do it. A built idea is never offered as a feature again: when the site says it too it is left out, otherwise it becomes saying it on the site. Free.

Inputs: checks (required).

ideas_repliesThe people who asked for a featureA
Read-only
Inspect

Once a feature built from an idea is live (its PR merged, or verified), the people who asked for it can be told it shipped. Returns the idea, the work recorded for it (with the live link), and the idea's own posts still worth a reply: Reddit threads under 150 days old (Reddit archives at 180), X posts under 28 days, one per thread, 5 at most, none already drafted for by any run. The replies come from ideas_replies_find, which also searches Reddit and X for people asking for it now. Free.

Inputs: key (required).

ideas_replies_findFind and write the replies about a feature that shippedAInspect

Once a feature built from an idea is live: the run behind Assisted posts (the same as reach_find), aimed at this feature, for one platform. The idea's own posts still open for a reply go first, then Reddit's or X's search for people asking for it or stuck on the problem it solves now, ranked and checked the way reach runs are (X a week old at most; Reddit open threads, each subreddit's self-promotion rules). One reply each, written to that post and telling them it shipped, up to 5; never a thread with a draft or a recorded reply already. Runs in the background, about two minutes. Costs $1.40, charged only when it writes drafts: tell the founder the price and wait for a yes. Returns the link to the drafts. Nothing is posted.

Inputs: key (required), platform (required).

ideas_replies_saveSave the replies to the people who askedAInspect

Save replies you wrote yourself to the people who asked for a feature that is now live, to Assisted posts in the results app, one draft per person (ideas_replies_find finds and writes them; use this only when the founder asks you to write one): each url one of ideas_replies' targets, one per thread, the text written to what that person said (X 280 characters as X counts them, links 23). Two replies that say much the same thing are refused. Returns the Assisted posts link, where each draft opens X's reply box filled in, or the Reddit thread to paste it in. The founder posts each one from there; you never open X or Reddit for them. Nothing is posted. Free.

Inputs: key (required), replies (required).

ideas_runRun a feature ideas studyAInspect

Search Reddit (the last year) and X (the last three months) for people talking about the problem this product solves, read the busiest threads' comments, read this site, and group what at least two different people ask for into features it could add, each with their posts as evidence. In the background, a few minutes; call ideas afterwards. Costs $0.90 from the balance, charged only when it returns. Not charged when fewer than 10 posts can be read. At most one a day. State the price and wait for a yes before every study.

Inputs: no named parameters.

ideas_skipLeave a feature idea outAInspect

The founder will not build this idea: it is never offered again, in this study or a later one. With undo, it comes back. Free.

Inputs: key (required), undo.

index_statusWhich pages Bing hasAInspect

Reads Bing Webmaster Tools now, for the site's main pages (home and the pages Shipfound shipped, ten at most): whether Bing has each one (crawled with a 2xx), when it last crawled it and the status it got. ChatGPT search reads Bing's index. Needs bing_connect first. Free.

Inputs: no named parameters.

keyword_researchKeyword researchAInspect

For one topic: search volume, CPC and difficulty for it and its related searches, the top 10 Google results (and where you rank), People Also Ask, up to 15 more searches around it (ideas, each with volume and difficulty; winnable is difficulty 30 or under, which a young site can reach the top 10 for), and the pages Perplexity cites with the brands it names. Pick a winnable idea with real volume over a hard one with more. Costs $0.06 from the balance, charged only when it returns. Nothing is charged when the data comes back empty.

Inputs: topic (required).

ladderTripwire LadderCInspect

Tripwire Ladder™: from a free diagnostic to a bigger payment, each rung counted from the product's own people over the last 90 days (days to change it): the diagnostic (its page's visitors, and the signups who used it), signup, the free part used (the activation rule), a first small payment and a bigger one (a second, or a larger one). Returns the definition, the counts, each rung with the share of the rung before that reached it, the rung that keeps the fewest (a missing diagnostic first) and what to build there, with its evidence. With define: what the diagnostic is, read from the code and the site: diagnosticPath (its page, "*" as a wildcard) and or diagnosticEvent (the event the product reports when it runs), and label. Free.

Inputs: days, define.

landing_checkLanding page check (retired)AInspect

Retired. The home page is now read in full by the convert routine: call funnel_check and follow routines/convert.md (/shipfound:convert). Free; reads nothing.

Inputs: url, skip.

launch_prepLaunch prep: taking part and the Product Hunt run-upBInspect

Everything before a launch, stored server-side. hnUser: the founder's Hacker News username, kept so the plan reads its karma daily and offers Show HN once it opens. topics: what the founder knows well enough to answer (up to 6), for finding threads. ihPosting: what the Indie Hackers new-post page showed in their Chrome (closed: "You can't create posts yet"). productHuntDay (YYYY-MM-DD): the launch day, which dates the Product Hunt run-up; done: a run-up step id the founder finished. threads (show_hn or indie_hackers): live threads where the founder's experience fits, minus the ones already shown or commented in, with the rules each comment draft keeps. Returns the gates, the run-up with today's step, and the threads. Free. Nothing is posted.

Inputs: done, hnUser, topics, threads, +2 more.

launch_targetsLaunch targetsA
Read-only
Inspect

The launch boards left for this product, only the ones that fit it: Show HN for something technical (pass hnUser, the founder's Hacker News username, and hn says whether Show HN is likely open to their account; a username stored with launch_prep is read without it), Indie Hackers when the buyers are founders (product page, then a launch post), DevHunt for developer tools, Product Hunt for software and apps, minus every step already recorded; notOffered names the ones that do not fit, with why. Each with its steps (where to submit, the fields the form takes, and how to record it), the founder's link with utm tags, what it needs, when to post, the board's rules, and what to do after. gates says which boards are closed to the founder's account (a closed step has closed: true; never fill it); open names the boards with a step open today; productHunt is the run-up, dated, once the day is picked; extras are the moves besides the launch (taking part, today's run-up step). readiness.blockers says what to finish first; readiness.freeTool is a free tool already shipped, the page Show HN links to. Free.

Inputs: all, hnUser.

listing_skipSkip a listing for goodAInspect

The founder will not list on this site or list (wrong fit, paid, rejected them): leave it out of listing_targets and today from now on. Takes the target's url, host or key. For a site they already listed on, use record_action instead, so it is checked. Free.

Inputs: site (required).

listing_targetsListing targetsAInspect

The next directories to list the product on: free to list (or free on a condition, stated in the note), open to this kind of product, not already recorded as listed, ranked by how often AI answers cite them, each with where to submit. Review profiles only when asked for in include; launch boards (Product Hunt, DevHunt, Show HN, Indie Hackers) are launch_targets. Free. With marketplaces true, instead the MCP registries, plugin lists, extension stores and GitHub awesome lists the product fits and is not recorded on yet. Free.

Inputs: count, include, marketplaces.

mail_setupSending addressAInspect

The address outreach emails go from, kept apart from the account the founder signs in with and from the Gmail the connector reads (say, a personal Gmail for GitHub mail and a company address for outreach). Sets it when address is given, and always reads its domain's mail records from DNS, from outside: who hosts the mailbox (MX), SPF, DKIM and DMARC, each with the exact record to add when it is missing. ready is true only when a mailbox on the domain can send and all three are in place. Free.

Inputs: address.

notes_contextBuild in public notes: what to write aboutB
Read-only
Inspect

What a build in public note can be about (a milestone from the site's hard goals, a launch, a feature shipped, a free tool live, a skill published, this week's commits when repoCommits is passed), each source written once; which platforms are open (X every 3 days, Reddit every 14, by the audit); the flagship X Article (article: open every 14 days, whether the account has X Premium, format article or thread without Premium, and the sources it can be about); the founder's voice per platform if learned; and the subreddits that take these posts, with their rules. Free.

Inputs: features, repoCommits.

notes_saveSave a build in public noteAInspect

Save one note's drafts to Assisted posts in the results app, for the founder to post: x (one post, 280 characters as X counts them, links 23) and or reddit (a subreddit from notes_context, a title, a body). image is the path of the image you made, for the founder to attach. Or, on its own, the long form: article (a flagship X Article: title under 100 characters, a body of 600 characters or more in Markdown with an image line caption where each image goes, the 5:2 cover and the images) or thread (2 to 12 posts of 280 characters, each with its image or none, for an account without X Premium); premium is what you saw on X's Articles tab. The source is marked written, so it is never offered again (an Article on its own, so a source can have a note and an Article); saving again for the same source revises a draft not posted yet. A giveaway's Reddit post can go to up to 4 subreddits, each saved with the same source and its own subreddit. Returns X's composer, the Articles tab, or Reddit's submit page. Nothing is posted. Free.

Inputs: source (required), x, reddit, thread, +2 more.

notes_voiceSave the founder's voiceA
Destructive
Inspect

Store how the founder writes on one platform, learned from their own posts (X: their profile in their Chrome; Reddit: posts or comments they paste, since Claude cannot open Reddit). Kept and reused for every note; saving again replaces it. Free.

Inputs: sample (required), summary (required), platform (required), rules, +2 more.

offer_planFounding offerB
Read-only
Inspect

What a founding offer starts from: the founder's stage (zero: no payment seen yet), signups and payments in the last year, any founding offer already recorded (offer) and the one verified live (live: what a boost leads with), three kinds of offer to propose (a founding price, a lifetime deal, a pre-order) with when each fits, and the rules every offer keeps (the founder sets every number, the cap is enforced by the payment provider, no fake scarcity or urgency). Free.

Inputs: no named parameters.

open_prOpen a pull requestAInspect

Through the Shipfound GitHub App, when the founder connected GitHub for this product: a new branch named shipfound/ off the default branch, one commit with the files given (each file's whole new content, or delete), and a pull request for the founder to review and merge. Never merges, never pushes to an existing branch, never touches .github/, env files, keys or secrets; at most 20 files, one theme per PR. Then record_action it (kind PR, url = the PR) and verify. For an agent without the code; in Claude Code or Codex use git and gh. Free.

Inputs: files (required), title (required), branch (required), body.

outbound_targetsOutbound listAInspect

People to write one short email to, from this product's outbound list. The list is filled from the sources that fit its buyers, picked from its brief, never by the caller: people who said in public in the last two weeks that they have the problem this product solves, asked for a tool like it, or complained about a tool named in its place (X posts and Hacker News comments, never Reddit: its users stay pseudonymous, so reach answers there in the thread), for every product; and, when its buyers are makers, founders, startups or software teams, teams who launched in the last two weeks on Show HN or today on Product Hunt. Model calls keep only people who could buy (no vendors, marketers, agencies or bots; for launches, small new teams with something to sell, no known brands, no rivals). Everyone is judged once and stays on the list until written to, skipped, or two weeks old, so asking again is free while it has people. When the list is short, a search runs in the background (a few minutes): call again afterwards. For each: found (pain or launch), the post or launch and its words, why, an angle to open with, and the email they published (their own profile, a Show HN author's "about", the launch's own site) checked with a verifier, or an address found and verified (a work email from their name and the site on their profile; for a launch, the address its domain's mail server accepts, a person's own before hello@). Never a guessed address. Up to count people with an address, then up to 3 pain posts with none, to answer in their own thread. People written to (record_action, meta.type "outbound", meta.person, meta.email) or skipped never come back, and no address is offered twice. The 20 inbox drafts a day are counted here: draftsLeftToday says how many are left, and a batch is never bigger. sender is the address the drafts go from (mail_setup). Reading the list is free. A search costs Costs $2.20 from the balance, charged only when it returns. charged only when it adds someone with an address; it starts on its own when fewer than count are ready and none ran in the last 6 hours, or with fresh. A call with skip only records the skips, free.

Inputs: skip, count, fresh.

outreach_targetsLists AI answers readAInspect

The "best X" and "X alternatives" pages AI engines cite when buyers ask, on other sites and without this product on them, most cited first: for each, the buyer questions it is cited for, the author from the page's own byline, and their work email when one is found and verified. A page with no verified email says why; use the site's contact page in the browser then. Pages already written to (record_action with meta.type "outreach") or skipped never come back. Costs $0.60 from the balance, charged only when it returns. for a batch with new pages to look up, and nothing when they all list this product already; pages looked up before come back free, and a call with skip only records the skips and looks nothing up, free.

Inputs: skip, count.

payments_connectConnect the payment provider, read onlyB
Read-only
Inspect

Revenue share: Shipfound takes 30% of what each paying customer it brought pays in their first 12 months (the first one is free), charged to the founder's card and added to their balance for more work. To count those customers it reads the product's payment provider with a key that only reads. This says where the founder pastes it (the billing page, never this chat) and how to make it for provider (stripe or dodo; both when left out), plus the two things the product needs: its signups reported to Shipfound (/shipfound:users) and the person's own id passed at checkout. For an iOS app (provider appstore, the default in an app's space): an In-App Purchase key, and the change to ship in the app (a random id for the person, the Apple Ads token at first open, the same id on each purchase); a subscriber counts when their install came through an Apple Ads keyword Shipfound added. Free.

Inputs: provider.

planThe planB
Read-only
Inspect

The ranked queue for this week, built only from what the latest access audit unlocked: { rank, module, title, why, command, price, evidence? }, and the founder's stage: zero (no payment seen yet) puts what wins a first customer first. evidence is what an item rests on: a number of the founder's own (signal), the play library's best grade for that kind of move (grade, library) and what it did for this founder before (past). Free. Work it top down; state the credits before running anything priced over 5.

Inputs: no named parameters.

pricing_checkPricing and payment checkAInspect

Whether people who reach the pricing page (a website) or the paywall (an app) can pay, for any stack and payment provider. Returns steps: each step from pricing to paid (a site: pricing seen, plan picked, checkout opened, paid, renewal or top-up, from the mapped funnels; an app: paywall seen, trial started, paid, renewed, from App Store Connect and the subscription service), each counted, silent or missing, with untracked first and paidGap when the analytics count far fewer payments than the provider; entry: the entry model the agent read in the code beside sourced benchmarks for this kind of product; own: the founder's own pricing changes and their before and after; walk: the checks to make in the founder's Chrome or the code, never paying or creating an account (steps-tracked, checkout-phones, wallets, local-price, promo-code, billing-page, paid-gated, paywall-exposure, dunning, trial-day0); changes: the changes ranked by evidence, the ones that answer a failed check first, and pick, the one to make; judge: how a change is read (paid per visitor, directional below 9,000 views per variant, with its stop date set now); hardLines. Call again with record (pass or fail with evidence per check), model (the entry model) and counts (what you read in the provider's dashboard or the subscription service). Never changes a price, a plan or a customer. Free.

Inputs: kind, model, counts, record.

qa_walkConversion QA WalkAInspect

Conversion QA Walk™: every step a new customer takes, from the page they land on to the screen after paying (entry, signup, verify, first-screen, first-win, upgrade, checkout, after-payment, billing), walked in the founder's Chrome at desktop and phone width, in-app browsers read from the code. With no input: the site read from outside (entry pages, the signup page, the pricing page, the misses the server already sees), the steps, 38 checks by area (copy, errors, layout, forms, in-app browsers, email, the first result, conversion, payment, speed) with how to make each, a measure script and a paint-time script, the rules (ask the founder before signing up with their email and a password you set, disable that account after, never pay), the last walk, and a test account still to disable. Call again with record for what the walk found: every step (walked, or why not), the issues (check, step, device, severity blocker, major or minor, what was seen, the fix, evidence), the checks that passed, and account { email } when a test account was made; returns the report, blockers first, and what a re-walk no longer sees. disabled: true once the test account is disabled. skip: issue ids the founder will not fix. Free.

Inputs: skip, record, disabled.

reach_draftsReddit or X draftsA
Read-only
Inspect

The drafts on Assisted posts for one platform: whether the last run is still going or why it found nothing, how many are left to post and posted in the last 30 days, each draft's thread or post, and the link to the page. The founder posts from that page; never post or paste a draft yourself. Free.

Inputs: platform (required).

reach_findFind Reddit threads or X conversationsBInspect

Start the run behind Assisted posts in the results app, for the platform the founder asked about. reddit: questions their buyers asked on Reddit this month, searched in the product's own communities first (the exact tool it plugs into, the buyer's exact job) with one broad sub beside them, a reply for each, plus a post of their own where a subreddit allows it, up to six drafts. x: posts from the last couple of days where their buyers talk about the problem the product solves, one reply each, up to five. Runs in the background, about two minutes; a run that finds nothing is not charged. Costs $2.20 for Reddit and $1.60 for X, charged only when it finds drafts: tell the founder the price and wait for a yes. Returns the link to the drafts. Nothing is posted.

Inputs: platform (required).

reach_markMark a Reddit or X draft posted or skippedAInspect

When the founder says they posted a draft (or will not), mark it, the same as the Posted and Skip buttons on Assisted posts, so it leaves the drafts waiting and is never offered again. A posted draft with the link of their reply is recorded as shipped (Claimed). Ids come from reach_drafts. Free.

Inputs: id (required), status (required), platform (required), url.

record_accessStore the access auditAInspect

Store what the access audit found: one entry per area (repo, hosting, gsc, bing, gmail, reddit, x, social, github, tracking, assets, marketplace) with green, amber or red, what you saw, the one action that turns it green, and facts the plan reads (accountAgeDays, karma, framework). With merge: true, only the areas given are replaced and the rest carry over from the latest audit (a routine that checked one area again, like /shipfound:social). Free. The plan is built only from the latest audit.

Inputs: areas (required), repo, merge, client.

record_actionRecord shipped workAInspect

Report anything you shipped with the founder: a PR (url = the PR, liveUrl = the page once deployed), a live page, a listing (liveUrl = our page it should link to), an index request, a post the founder published, or a Gmail draft. https URLs only. Free. It is stored as Claimed; call verify to check it (free), and Claimed PRs, pages, listings and posts are re-checked daily for free for 30 days. Recording the same URL again updates it. Put fix ids in meta.fixIds for site fixes. A PR in a private repo is confirmed merged by record_merges, which grow runs from today's confirm.prs. A listing: record the listing page once it is live; recorded on the directory's submit or account page it waits as submitted, and the listing page recorded later replaces it.

Inputs: url (required), kind (required), title (required), module (required), +2 more.

record_lessonRecord a lesson for every founder's agentAInspect

Teach Shipfound's brain something this session showed that no number will: a platform rejected, removed, flagged or banned something; a step failed; something worked better than expected; or the founder corrected how you work. Write it so it holds for any product: no product, person, account or company names, and no numbers that identify anyone. One lesson per thing, when it happens, not a summary at the end. It counts towards one rule; a rule goes live for every founder's agent once enough founders' lessons back it, or an admin approves it. Free.

Inputs: kind (required), rule (required), tried (required), happened (required), +5 more.

record_mergesReport merged pull requestsAInspect

The pull requests gh read in the founder's repo (gh pr list --state all --json url,state,mergedAt), for the Claimed PRs Shipfound cannot see (today lists them in confirm.prs). Each merged one is stored as merged and checked at once (its live page, from outside), one closed without merging fails, open ones wait. PRs never recorded are ignored. Free.

Inputs: prs (required).

reddit_noticesWhat Reddit said backAInspect

Record the emails from Reddit (noreply@redditmail.com) that grow's confirm.reddit asks you to read in the founder's Gmail: a subreddit removing a post or comment, a ban, or a ban lifted. A removal closes that subreddit to drafts until the founder says to try it again (reopen); a ban closes it for good, and the drafts still waiting there are skipped. Pass an empty list when there are none, so the read counts. reopen: subreddits the founder asked to try again after a removal; a ban cannot be reopened. Free.

Inputs: notices (required), reopen.

repo_confirmConfirm the repoAInspect

Whether the repo you are in is this site's code, kept so nobody is asked again. Call it when workspace says the repo is UNCONFIRMED: by agent, yes only, with evidence (the file and line where you found the site's domain); by founder, their yes or no. The founder's answer always stands over yours. Free.

Inputs: by (required), repo (required), answer (required), product, +1 more.

repo_readRead the product's repoA
Read-only
Inspect

Through the Shipfound GitHub App, when the founder connected GitHub for this product (Settings): with no path, every file and folder of the repo on its default branch; with a folder, everything under it; with a file, its text (up to 300 KB). Never env files, keys or other secrets. For an agent without the code (ChatGPT, Claude); in Claude Code or Codex read the local repo instead. Free.

Inputs: path.

researchPeer study, latestB
Read-only
Inspect

The latest study of up to 8 products a step ahead of this one, each found through a lens (peers[].lens) or named by the founder (via "founder"; named lists the ones kept for every study): same_job (it does this product's job, in any form; peers[].job says whether the whole job or one piece of it, and launchedAt when it launched), same_buyers (its buyers also pay for it), same_shape (sold and installed the same way). What each shows in public today (the first screen, the way to signup, pricing, free tools, launches, listings, top X posts) and how it started (read.early: its home page in the Wayback Machine's first captures, its launches with points, its early posts), and the patterns: today (two or more do it and this site does not) or early (an early move, one product enough when it has outside proof), each with the products' pages, their own words, a first step for this product, its key and the move it becomes. For an iOS app the products are apps (peers[].app, read on the App Store; peers[].domain is the app's key, id.apps.apple.com): the apps that top the app's own App Store searches with more ratings, each with its listing (name, subtitle, price, in-app purchases, rating and ratings, screenshots, version dates) and what its reviews say about the trial, price, subscription, paywall and ads; the app's own listing is founder.app, and each pattern's move is a part of the aso routine. Patterns already done (recorded with meta.research) and products removed with research_skip are left out. Also whether one is running, when the next free one is, and the price of one now. Free.

Inputs: no named parameters.

research_runRun a peer studyAInspect

Find up to 8 products a step ahead of this one (the same job, the same buyers, sold the same way), read what each shows in public today and how it started, read this site the same way, and find what it can learn from them, each with evidence, a first step and the move it becomes. In the background, a few minutes; call research afterwards. Needs a finished AI visibility check; for an iOS app, its App Store search check instead (the week's listing set), and the apps studied are the ones that top those searches, read on the App Store. Costs $1.30 from the balance, charged only when it returns. Not charged when fewer than 2 such products can be read. At most one a day. State the price and wait for a yes before every study. domains: products the founder has in mind, by domain or URL (an app by its App Store link); they are studied first in this study and every one after it (at most 5 kept, the newest last).

Inputs: domains.

research_skipLeave a product out of peer studiesAInspect

Remove a product the founder says is not like them (sells to other buyers, is far bigger, is not a product at all) from this study's patterns and from every study after it, by its domain or a URL on it. With undo, it can be studied again. Free.

Inputs: domain (required), undo.

routineRead a Shipfound routineA
Read-only
Inspect

The written procedure for a piece of work (grow, audit, status, seo, fix, write, list, launch, outbound, reach, boost, aso and the rest), the same text the plugin reads, with its pointers to other routines as routine calls; references/<name> for a reference, skill for the whole skill. Without a name, the list. Follow it as written; without the founder's code, read "open a PR" as giving the change to paste. Free.

Inputs: name.

search_positionsSearches your site almost winsAInspect

The Google searches this site ranks in the top 20 for (US), from an index of Google results that is refreshed every few weeks: targets are the ones at 4 to 20, most searched first, each with its page, monthly searches and difficulty; changes is what moved since the last check. Lift one target per PR on the page that already ranks. Costs $0.10 from the balance, charged only when it returns. Nothing is charged when the site ranks for nothing yet.

Inputs: no named parameters.

seo_crawlCrawl the site's pagesAInspect

Read every page in the sitemap, the ones search shows most first, up to 60: what each returns, noindex and canonicals, titles (too long, shared, the page's best search not at the start), H1s, thin pages, links that lead nowhere, Core Web Vitals for the top pages, and which of the pages AI answers lean on the site has (a "what is" page, an AI info page, comparisons, integrations, use cases). Free; kept for seo_set.

Inputs: no named parameters.

seo_programmatic_checkCheck a programmatic page setA
Read-only
Inspect

Before a set of pages from one template ships: every page must carry its own data (a data field whose value repeats on no more than a fifth of the pages), Search Console must show people search the pattern (three searches or more), and the set goes out at most one page a day. Google's 2026 spam and core updates hit templated pages that only swap a name. Free.

Inputs: pages (required), pattern (required), dataFields (required).

seo_readRead the site's search dataAInspect

Read what Google and Bing already show for the site, last 28 days against the 28 before: per search and page, clicks, impressions, click rate and position. Google from rows the agent read in the founder's browser, where they are signed in to Search Console (Performance, 28 days: each top page's searches), and prev (each page's clicks the 28 days before); without rows, Shipfound's own Search Console read where it already has access. Bing through its stored key. Free; the reads are kept for seo_set and grow.

Inputs: prev, rows.

seo_setThis week's SEO and AI search workA
Read-only
Inspect

The week's set, picked from the stored search reads (seo_read), the crawl (seo_crawl) and the latest AI visibility run, so the founder does not choose item by item: title rewrites with the most clicks to win back, lifts onto page one, internal links anchored in each target's own best search, a refresh of a page that lost clicks, a new page for a search no page owns, the site fixes, a "what is" page and an AI info page when missing, AI answers lost with their gap, and Bing. Each action says its routine step and what to record (record_action meta), so it is read at 28 and 56 days against the whole site. Also the reads of changes shipped before, and price: what doing the set costs (the research for each page it writes, the lists AI answers cite for a lost answer; the rest is code changes and free). This call is free.

Inputs: no named parameters.

shippedShipped workB
Read-only
Inspect

Every recorded action with its state (CLAIMED, VERIFIED, FAILED) and what the last check saw. Free.

Inputs: state, module.

shorts_researchSlideshows working for your buyersAInspect

The top TikTok posts of the last 180 days for up to 6 searches your buyers would type there (write them from the product's brief and buyers, in their words: "coding games for kids", not the product's name), slideshows (photo posts) first, with plays, likes, saves, slide count and caption; and the creators behind them with 3,000 to 300,000 followers, with the email their bio publishes (never guessed). Also each post's tracking link: an App Store campaign link for an app (ct=sf-shorts-..., with the provider token saved on the app's site settings) or a utm_source=tiktok link for a site. Use it once a week for /shipfound:shorts (routines/shorts.md). Costs $0.03 from the balance, charged only when it returns.

Inputs: searches (required).

sign_inSign inAInspect

Sign this session in to Shipfound from the chat. Signed out, the first call returns a link and a code: open the link in the founder's browser and print it too, ask them to check the code matches, pick the site and choose Allow, then call sign_in again. Each later call waits up to 40 seconds for their answer. Pass device (the hash the plugin's device script prints) and the same Allow signs in this machine for every later session too. Signed in, it says which site this session works on. Free.

Inputs: client, device.

site_fixesSite fixesAInspect

Audit the live site the way AI crawlers and Google read it (robots rules for AI crawlers, firewall, rendering, indexing, canonicals, page titles and descriptions, structured data, sitemap, llms.txt, internal links to key pages, share images, answer pages) and return fix specs { id, theme, page, issue, evidence, fix } grouped by theme, one PR per theme, minus fixes already shipped. Costs $0.02 from the balance, charged only when it returns. Nothing is charged when it finds nothing to fix. When you record the PR, put the fix ids in meta.fixIds so they are not suggested again. The robots fix is the whole corrected robots.txt, with a note on each crawler it changes for the PR. Training crawlers (GPTBot, ClaudeBot, CCBot...) are the founder's call: while they have not answered, that fix carries fix.choices, the whole file for allow, block and keep; ask, use the one they pick, and put their answer in the PR's record as meta.training so later checks follow it.

Inputs: url, training.

social_setupYour TikTok and Instagram accountsA
Read-only
Inspect

Where the founder's TikTok and Instagram stand, from the audit's social area (ready, unfinished with what is left, missing, or unchecked), whether organic posts wait for them, and each platform's bio link: the site with utm_source=&utm_medium=social&utm_campaign=sf-social, or for an app its App Store link with ct=sf-social- (and a Google Play link when you pass the package name). Also the Meta business portfolio and Page the boost uses, for connecting Instagram to it. Use it in /shipfound:social (routines/social.md). Free.

Inputs: playPackage.

todayTodayCInspect

What /shipfound:grow shows: what happened since the founder's last session (AI visits, AI crawler hits, conversions, what got verified or failed), what is due (tests with a verdict, shipped work to verify), the one move to offer, the next four (after), every other move with work behind it (more), and every other kind of move Shipfound makes (catalog, with ready false and what it needs when something comes first), so a founder can reach any of it. focus is what holds the product back this week, read from its numbers, and the five moves go after it. bet is the week's goal and bet with its check day; take is Shipfound's own view of the week, which may disagree with the founder (disagrees); calls is what came of the founder's own calls over its first pick; question is today's one question, when an answer would change the plan; happened carries the verdicts on shipped work as they are read. Each move's why is the reason to do it for this product today, chosen and written over the founder's own results, the people who asked, the peer study and the play library (what it does is in does when why is that reason); gets is who it reaches and the first sign to watch for; then is what it leads to once its own work is done; rests is what it rests on in one line. It looks first, from stored data: a move is offered only when there is concrete work behind it (checks still failing on the live site, directories not listed yet, the page worth writing with its volume), and not the same move two days running. Logs the offer. Free.

Inputs: features, repoCommits.

tracking_checkCheck trackingB
Read-only
Inspect

Whether the live site is sending events, crawler hits and goals, and what is still missing, in plain words. Tracking turns green when all three have arrived. Free.

Inputs: siteId.

tracking_installInstall trackingA
Destructive
Inspect

Set up tracking for the site: the site key, the secret (shown only the first time, or with rotateSecret), the tracking.js script tag, the AI crawler middleware for the stack (nextjs, astro, nuxt, sveltekit, cloudflare; static sites get a log shipper note), and the default goals and funnel. Free on every plan; Free and Builder track 1 site, Growth 3. Ship it as the first PR and never commit the secret.

Inputs: domain (required), framework (required), identityMode, rotateSecret, +1 more.

trumpetTrumpet: the creatorsCInspect

Trumpet™: the creators found for this product's buyers (influencers.club), each with their status (found, contact: email and views in, written, replied, deal, posted, paid), their tagged link, their average views, the three ways to pay them priced at the founder's price per 1,000 views (options: flat, perView with its cap, upfrontBonus), and for posted ones what their post brought by its link. cpmUsd: the founder's price per 1,000 average views, asked once and kept. mark: one step for one creator (written, replied, deal with model flat, per_view or upfront_bonus and its numbers, posted with the post's link: recorded with its campaign so its visits, signups and revenue are read, paid with what the founder paid, skip). Free.

Inputs: mark, cpmUsd.

trumpet_contactTrumpet: emails and viewsAInspect

Trumpet™: for up to 10 creators the founder picked (keys from trumpet_find), their email (influencers.club, only a validated one, never guessed), whether they did brand deals, their bio, and their average views from their recent posts. $0.28 for each creator with an email; one without costs nothing.

Inputs: keys (required).

trumpet_findTrumpet: find creatorsAInspect

Trumpet™: one page of up to 20 micro creators (3,000 to 150,000 followers or subscribers by default) on youtube, tiktok, instagram or twitter, found on influencers.club by niche (a line on who they are and who watches them, written from the product's buyers) and sized on the platform's own field; keywords for their bios; brandDeals true for those who did brand deals before. Returns the new ones (each with a key, handle, name, followers, engagement) and the total that match. $1.20 a page, charged only when creators come back: ask the founder first.

Inputs: niche (required), platform (required), max, min, +3 more.

ugc_planPlan an AI presenter videoAInspect

An AI presenter video for an ad or a post (routines/ugc.md): shot 1, a generated presenter (an adult, nobody real) says the hook to the camera as a selfie for 4 seconds; shot 2, the same person over the shoulder at a laptop (a website) or holding a phone (an app), the screen solid green for the video kit to put the product's real screens on, while the same voice says the rest; 15 seconds at most, 720p, 9:16. Never for an App Store preview: those are screen captures only. Call it first with the founder's answers (use: ad or post; platforms: meta, tiktok or both; presenter: keep one for this product or a new one each time), each asked once and kept: it says which questions are still open and whether each platform is ready (an ad: its ad account and pixel; a post: the founder's own account, Business or Creator with a tagged link in the bio). Nothing is priced until they are. Then call it with the script (the hook; shot 2 as lines, each with the screen beat it is about, in order; the end line under the end card; from the customer's side, never the presenter as a customer: no "I used", "I tried", "my results") and, for a new presenter, who they are: it checks both, builds the prompt and prices it from Higgsfield's estimate plus the margin ($9.78 at most). Free. The price is above $1: say it and wait for the founder's yes before ugc_start.

Inputs: end, use, who, hook, +6 more.

ugc_startMake the AI presenter videoAInspect

Make a priced AI presenter video from ugc_plan, after the founder said yes to its price: holds the whole price from the balance and starts the images (the presenter's portrait when new, then the over-the-shoulder frame). With frames ok, after you looked at both images (ugc_status), makes the clip; with frames stop, ends it, charged for the images only. Charged at Higgsfield's cost plus the margin for what is made; a request Higgsfield fails or flags is not charged. $9.78 at most.

Inputs: job (required), frames.

ugc_statusWhere the AI presenter video isAInspect

Poll an AI presenter video from ugc_start: images being made, the two images ready for you to look at (then ugc_start with frames ok or stop), the clip being made, or done with the clip's URL (download it now: Higgsfield deletes it after 7 days), what was charged, and the bio links for TikTok and Instagram (utm tags for a site, an App Store campaign for an app). A failed or flagged request ends it, charged only for what was made before. Free.

Inputs: job (required).

users_activationSet what counts as an activated userA
Destructive
Inspect

The rule that counts a new user as activated (the users report): they did event (an event name the product's server sends to /t/u, like project_created; empty for any product action) at least minCount times within withinDays of signing up, worth at least minValueCents together (0: no value needed; above 0, only events with a value count). Pick the one action that means they got what they came for, from the code; for a product paid by use, the action that costs money, with its cost as the event's value (e.g. spend, minValueCents 1). Parts left out stay as they were. Free.

Inputs: event, minCount, withinDays, minValueCents.

verifyVerify shipped workBInspect

Check one recorded action from the outside: a PR's state on GitHub and its live page, a page live and naming the product, a listing linking to the site (with its rel), a post still up (X through its embed endpoint; Reddit removals are detected when Reddit lets the check through, otherwise the recorded link counts). Free. Index requests and drafts cost nothing: a Bing index request is checked in Bing once Bing is connected (bing_connect); other index requests and drafts cannot be verified by us.

Inputs: actionId (required).

visibilityAI visibility, latest checkA
Read-only
Inspect

The latest finished full check: every question and engine pair with its stability label ("named in 3 of 4 runs"), the brands named in your place, and the pages the answers cite instead of you (most cited first, each with its type, whether you are on it, and the command that gets you there). Free. Named means: Your product appears in at least 2 of 4 runs, on at least one engine, for at least one of your tracked questions.

Inputs: no named parameters.

visibility_runRun the AI visibility checkAInspect

Ask 10 buyer questions on every engine, 4 runs each, in the background (about 10 minutes); call visibility afterwards. The first check is the baseline, day 0 on the proof page, and is free. After that a re-check costs $2.80 from the balance, at most one a day, charged only when an engine answers. State the price and wait for a yes before a re-check.

Inputs: no named parameters.

workspaceThis workspaceA
Read-only
Inspect

The product this key belongs to: name, URL, the account's balance in dollars (the free credit while it lasts, and what was paid), the access summary, tracking state, and the links to the results app and proof page, plus whether the repo you are in is this site's code. Free. Call this first, with repo.

Inputs: grow, repo.

writing_checkCheck a post or reply reads as the founder's ownA
Read-only
Inspect

Before a post or reply the founder built pick by pick is filled in: flags what reads as AI (an em dash, stock hype words, a label-and-colon opener, a tidy list, three short punchy sentences in a row, more than two hashtags, a pitch at the end, a link in an X reply), each with the words and why; confirms the founder's own sentence is in it as they typed it; and how much of the final text they typed beyond the options picked. Never rewrites: say each flag and let the founder change it or keep it. ready is false until their own sentence is in. Free.

Inputs: own (required), kind (required), text (required), platform (required), +1 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Remote MCP server that lets AI assistants read tracked competitive intelligence — competitor news, reviews, website changes, social posts and ads — and act on it by managing projects, competitors, battle cards, reports and canvases. Every answer carries a source and a date, and write actions only publish when explicitly shared.
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Enables brand visibility monitoring across major AI platforms like ChatGPT, Claude, Gemini, and Perplexity. It allows users to track visibility scores, analyze competitor data, and receive actionable insights to improve AI-generated brand recommendations.
      16
      11 npm
      1
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Browse IndustryLens's published competitive-intelligence reports and head-to-head competitor comparisons from any AI agent — real, source-backed data.
      MIT
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.

    Resources