Gentic Startup — Documentation

1. Getting Started

Sign Up & Get Your API Key

Before you can use Gentic Startup, you need an API key to authenticate your requests.

1. Go to gentic.co/startup and create an account.
2. Create an organization from your dashboard. API keys and billing are scoped to the organization.
3. Generate an API key and use it as a Bearer token in your MCP client.

2. Connecting to the MCP Server

The server is available at https://mcp.gentic.co/startup. For Claude Code:

claude mcp add gentic-startup \
  --transport http \
  https://mcp.gentic.co/startup \
  --header "Authorization: Bearer YOUR_API_KEY"

For Claude Web and ChatGPT you can also connect via OAuth — no API key needed. See the connect section on the landing page for other MCP clients (n8n, OpenClaw).

3. Agent Skill

For the best results, pair the MCP server with the Gentic Startup agent skill. The MCP server gives your agent tool access; the skill teaches it the optimal workflow order. Both the raw SKILL.md and a ready-to-upload .skill bundle are generated on demand from the live manifest, so they always reflect the current tools and pricing.

Add the skill directly via URL:

https://gentic.co/startup/SKILL.md

Or upload a .skill bundle to Claude Managed Agents:

https://gentic.co/startup/gentic-startup.skill

Download this file and upload it wherever Claude Managed Agents asks for a .skill file. It's a zip bundle generated on demand from the latest SKILL.md.

4. When to Apply

• User is exploring a new business idea and wants a structured gut-check before committing time.
• User wants market signal — Reddit sentiment, Google Trends interest, or web coverage — before building.
• User wants to save free-form research notes against an idea — supplier deep-dives, founder stories, lift-able quotes, tagline drafts, packaging hooks — so in-progress findings outlive the chat.
• User needs to name a business, product, or side project and wants candidates with domain suggestions.
• User wants to check domain availability and pricing before buying.
• User wants a competitive landscape overview for a bootstrapped business.
• User needs a brand identity foundation (positioning, voice, colors, fonts, persona).
• User wants to extract a canonical brand guidelines document (colors, typography, voice, imagery, aesthetic) from an existing public website, or look up a previously extracted record for the idea's brand.
• User wants the agent to generate landing-page HTML (rather than hand-writing it) and ship it as a live page.
• User wants to ship a branded landing page with built-in email lead capture to a live URL.
• User describes a change to a live landing page in prose — e.g. 'add a testimonial section after the hero', 'remove the pricing block' — rather than spelling out exact strings to replace.
• User wants to see the version history of a landing page, inspect a prior HTML revision, or roll back to a previous version.
• User wants the idea's landing pages to live on a specific brand subdomain on gentic.run (e.g. `pistash.gentic.run`), or wants to pivot the brand name and reattach the idea to a different subdomain before deploying.
• User wants to connect a custom domain they own so a landing page serves from their own URL.
• User wants to generate on-brand ad images before launching paid campaigns.
• User wants to launch, monitor, or iterate Meta ad campaigns (Facebook/Instagram).
• User wants to launch, monitor, or analyze Google Ads search campaigns — keyword research, campaign/ad-group/RSA creation, budget management, performance reporting, search-terms mining, GAQL queries, or AI-narrated period-over-period analysis.
• User wants to recall what was said or decided in past Slack/Telegram conversations about an idea, decision, or topic.
• User wants to retrieve or revisit results from earlier startup tool calls.
• User wants to track multiple business ideas in parallel and see which ones are exploring, validated, active, or paused.
• User wants to mark an idea as the one they're actively building (or shelve one to revisit later).

5. Workflow

1. 1. Start by creating an idea with `startup_create_idea` (free)

   Before most other tools, call `startup_create_idea` with a unique kebab-case `idea_slug` (e.g. `pet-subscription-box`, `ai-tutor-app`) and a human-readable `name`. Optionally pass a `description`. Most subsequent tools require the same `idea_slug`, so all research, validations, names, competitor findings, brand identities, landing pages, and ads accumulate against that idea. The call also best-effort auto-claims a matching brand subdomain on gentic.run (e.g. name `Tez` → `tez.gentic.run`) and attaches it to the idea so future landing-page deploys land on the right brand host. Inspect the response: `subdomain` (attached label), `subdomain_auto_claimed` (boolean), and `subdomain_auto_claim_reason` when the auto-claim was skipped (`reserved` / `invalid_base` / `matches_default` / `all_suffixes_taken` / `cap_reached` / `attach_failed`). On a skip with a remediable reason, suggest calling `landing_page_claim_subdomain` with a different label. Use `startup_list_ideas` (free) any time to see what's already there before creating a new one — pass `include_paused: true` to include shelved ideas.

2. 2. Run market research with `research_search_web`, `research_search_reddit`, and `research_google_trends`

   Three complementary signals, all org-scoped and persisted. `research_search_web` (5¢/call) uses Serper.dev for current news, reviews, competitors, and press. `research_search_reddit` (5¢/result, min 5¢) pulls consumer discussions with filterable subreddits, sort order, and time window — great for raw pain-point language. `research_google_trends` (10¢/call) returns interest-over-time and regional breakdowns for 1-5 keywords. Replay any prior run with `research_get_results` (free) — filter by `run_id`, `source`, or `limit`.

3. 3. Save in-progress research notes with `startup_save_research_note` (free)

   Use this to persist anything the agent synthesizes between formal tool calls — supplier deep-dives, founder stories, lift-able quotes, tagline drafts, packaging hooks — so findings outlive the chat. Pass the `idea_slug`, a short `title` (≤200 chars; used as the S3 filename slug and the row title — pick something specific like 'Rhody Wild supplier deep-dive'), a `markdown` body (≤200,000 chars; stored verbatim, use headings/lists/blockquotes freely), and an optional `sources` array of up to 50 cited URLs (each ≤2000 chars). The note's markdown body is written to S3 as a canonical, editable artifact and a row is inserted into `startup_results`, so it surfaces in `startup_get_results` (filter `tool_name='startup_save_research_note'`) and counts toward `startup_list_ideas.result_count`. Append-only — to revise, save a new note rather than overwriting. **Critical disambiguation.** When the user says "save this research" / "save that research note" / "save these findings" after running `research_search_web`, `research_google_trends`, or `research_search_reddit`, they mean **synthesize the findings into a markdown note and call `startup_save_research_note`** — they do NOT mean "the run_ids are already stored." Auto-stored run_ids are raw search rows in `research_results`; a research note is the agent's synthesis (themes, strategy, recommendations, keyword tiers, action items) that the user will actually read again. Consider calling `startup_save_research_note` whenever the synthesis represents a meaningful next-step the user will revisit — and never substitute "your run_ids are saved" for an actual note.

4. 4. Validate the idea with `startup_validate_business_idea` ($0.15/call)

   Pass the `idea_slug` plus the full `businessIdea` (what it is, who it's for, how it makes money) and optional `founderContext` (skills, budget, time availability, location, audience). Scores 5 criteria and returns a verdict (Strong / Promising / Needs Work / Rethink), strengths, risks, and concrete next steps. Frame the verdict honestly — it is tuned for bootstrappers, not VC growth stories. Pass `webhook_url` to run async (30-90s otherwise).

5. 5. Generate names with `startup_generate_names` ($0.15/call)

   Pass the `idea_slug` plus `businessDescription`, `targetEmotion` (the single dominant feeling — relief, momentum, wonder, belonging), `brandTone` (playful↔serious, innovative↔traditional), `nonStarters` (words or associations to avoid), and `industry`. Returns 20 names across 5 categories with memory/meaning/range scores and a top 3. Pair with `startup_check_domain_availability` to verify favorites. Pass `webhook_url` to run async.

6. 6. Check domains with `startup_check_domain_availability` (free)

   Scoped to an `idea_slug`. Two modes, usable together: pass `domainNames` (up to 50) for exact availability on specific domains, and/or a `keyword` for TLD-wide search. Use `tldFilter` to restrict keyword results (e.g. `['com', 'io', 'co']`). Returns purchasability, pricing from Name.com's live API, and TLD info. Free — run this aggressively.

7. 7. Research competitors with `startup_research_competitors` ($0.15/call)

   Pass the `idea_slug` plus `businessDescription`, optional `industry`, `knownCompetitors` (names/sites you already know), and `focusAreas` (pricing, customer acquisition, support weaknesses). Identifies 6-10 competitors across direct, indirect, and adjacent categories, maps positioning and pricing, and surfaces differentiation opportunities. Pass `webhook_url` to run async.

8. 8. Build brand identity with `startup_generate_brand_identity` ($0.15/call)

   Pass the `idea_slug` plus `businessDescription` and optional `businessName`, `industry`, `brandPreferences` (reference brands, desired tone), and `targetAudience`. Returns positioning (statement, elevator pitch, taglines), personality (archetype, voice, values), visual direction (color palette with hex, typography with free font suggestions, logo direction), a target persona, and the brand story. Pass `webhook_url` to run async.

9. 9. Extract brand guidelines from a live site with `startup_extract_brand_guidelines` ($3/call, async)

   When the idea already has a brand online — or the user wants to model an existing reference — call `startup_get_brand_guidelines` (free) first with a `domain` or `url` to check for a cached record. If nothing is stored, run `startup_extract_brand_guidelines` (**$3/call, async — pass `webhook_url`**) to crawl the site, combine HTML/CSS parsing with vision-model analysis, and write a canonical document (colors, typography, voice, imagery, aesthetic direction, heritage, generative guardrails — each field with source + confidence + evidence). Feed the returned colors/fonts/voice into `startup_save_brand_style_guide` to make every landing page deployed for the idea match the extracted brand automatically.

10. 10. Persist brand choices with `startup_save_brand_style_guide` (free)

    Pass the `idea_slug` plus any subset of brand fields (`primary_color`, `secondary_color`, `accent_color`, the `*_color_name` variants, `heading_font`, `body_font`, `voice`, `personality_traits`, `visual_mood`, `logo_direction`). Omitted fields keep their current value if a guide already exists. The saved guide is applied automatically to any landing page deployed with that `idea_slug`.

11. 11. Manage brand subdomains: `landing_page_claim_subdomain` / `landing_page_list_subdomains` / `landing_page_release_subdomain` (free)

    Each org's original slug is auto-claimed as its default subdomain (`{org-slug}.gentic.run`). To run multiple brands off one account, call `landing_page_claim_subdomain` with a `subdomain` label (3-63 chars, lowercase alphanumeric + hyphens; reserved labels like `www`, `api`, `app`, `admin`, `mail`, `assets`, `static`, `cdn`, `mcp`, `auth`, `docs`, `blog`, `dashboard`, `console` are rejected) to reserve additional brand hosts. Subdomains are globally unique across orgs — collisions return a structured `taken` error. Use `landing_page_list_subdomains` to see everything the org owns; the entry with `is_default: true` is the auto-claimed org slug and cannot be released. `landing_page_release_subdomain` frees a label but refuses if any active landing page is still pinned to it. These are aliases of the `claim_subdomain` / `list_subdomains` / `release_subdomain` tools on `/landing-pages`.

12. 12. Pivot the brand mid-stream with `startup_update_idea_subdomain` (free)

    When the user iterates on the brand name *before* deploying landing pages (e.g. 'Blueberry Bar' → 'Bluey'), call `startup_update_idea_subdomain` with the `idea_slug` and a `new_subdomain` label. It claims `new_subdomain` if not already owned, attaches it to the idea row, and releases the previously-attached subdomain when no active landing page still references it. Idempotent — passing the current subdomain is a no-op. Setting `new_subdomain` to the org's default behaves like having no subdomain attached (deploys still default to the org host). Does **not** rename `idea_slug` or any landing-page path slugs already deployed — those continue to serve at their existing URLs. On a `taken` error (another org owns the label), suggest a variant. On a structured `attach_failed` error, the new claim is rolled back automatically and the idea row is unchanged — safe to retry.

13. 13. Generate landing-page HTML with `landing_page_generate` ($7.50/call, async)

    Pass a freeform `brief` describing the page (purpose, audience, sections, voice, calls-to-action) and Claude Opus 4.7 produces a complete, self-contained HTML document on a Modal worker. Returns immediately with a `job_id` and a `draft_id`. The result posts back to the conversation automatically when the job completes (~1–5 min), and `list_asset_jobs(type='landing_page')` shows status. For programmatic integrations, pass `webhook_url` to receive a POST callback to your own service. Optionally pass `idea_slug` (drives colors/fonts/tone from the saved brand style guide), `reference_url` (preferred over legacy style guides — uses canonical brand guidelines and reproduces the original's structure when cloning; adds a **10¢ surcharge** because the server auto-fetches the rendered source via ScrapingBee, same price as `fetch_rendered_page`. Pass `base_html` instead if you've already fetched the source yourself), `base_html` (iterate on existing markup), and `style_hints` (free-form overrides). $7.50 is charged **only on success**.

14. 14. Deploy a landing page with `landing_page_deploy` (25¢ from a draft, $7.50 from raw HTML)

    Pass a `slug` (3–64 chars, lowercase alphanumeric + hyphens) and a `title`. Then either pass `draft_id` from `landing_page_generate` (**preferred — 25¢**, server promotes the S3 draft) or complete self-contained `html` (legacy raw-html path — $7.50). They're mutually exclusive. Optionally pass `subdomain` to host under a specific brand host (must be claimed by your org). Subdomain precedence when omitted: explicit input → idea's auto-claimed subdomain (when `idea_slug` is provided) → org default. Optionally pass `idea_slug` to auto-inject brand CSS, `description`, or `reference_url` for provenance. Set `ignore_brand_style_guide: true` to skip injection. The page goes live instantly at `{subdomain}.gentic.run/{slug}` and the response includes `subdomain` + `url` reflecting the actual host — never reconstruct URLs from `org_slug + slug`. Slug uniqueness is scoped per subdomain. Use `landing_page_list` (free) to see everything currently deployed; rows include `subdomain` per page and accept an optional `subdomain` filter.

15. 15. Iterate mechanically with `landing_page_patch` (50¢/call)

    Use this when **you can spell out the exact old/new strings** — copy fixes, image src swaps, color tweaks. Call `landing_page_get_html` (free) to read the current HTML plus its `content_hash`, then `landing_page_patch` with `page_id` and an `edits` array of `{ old_string, new_string, replace_all? }`. Pass the hash as `expected_content_hash` for optimistic concurrency. For prose-described changes ("add a testimonial section after the hero"), prefer `landing_page_edit` ($1) — the server uses Gemini to compute the patch ops for you. Reach for `landing_page_replace` (25¢ from a draft, $7.50 from raw HTML) only for layout changes or full rewrites.

16. 16. Describe edits in prose with `landing_page_edit` ($1/call)

    Use this when the user describes a change in natural language — "add a 3-card testimonial section after the hero", "remove the pricing block", "swap the CTA from 'Sign up' to 'Get early access' everywhere". Pass `page_id` and a freeform `brief`. The server fetches the live HTML, asks Gemini to compute minimal-diff string-replacement edits, and applies them. Cheaper than `landing_page_replace` (full Opus rewrite) and more capable than `landing_page_patch` (mechanical only). Optionally pass `expected_content_hash` from `landing_page_get_html` for concurrency safety. **Tier picker:** mechanical and you know the strings → `landing_page_patch` (50¢). Prose-described targeted change → `landing_page_edit` ($1). Layout overhaul or full rewrite → `landing_page_replace`.

17. 17. Browse and roll back history: `landing_page_list_versions` / `landing_page_get_version` / `landing_page_restore_version`

    Every `deploy`, `replace`, `patch`, and `restore` writes an immutable HTML version. Call `landing_page_list_versions` (free) with a `page_id` to enumerate versions with `version_id`, `created_at`, content hash, byte size, and `source` (`deploy` / `replace` / `patch` / `restore`). Use `landing_page_get_version` (free) to fetch any historical HTML for inspection or diffing. Roll back with `landing_page_restore_version` (25¢) — the restore writes a new `source: "restore"` version pointing at the historical content and promotes it live, so the prior current version stays in history (a restore is itself reversible).

18. 18. Capture and export leads (all free)

    Every deployed page includes a lead capture endpoint at `POST /api/leads/:orgSlug/:pageId` (accepts `email` required, plus optional `name`, `source`, `metadata`). Query submissions inline with `landing_page_get_leads` (paginated, max 500/page). Export a signed CSV with `landing_page_export_leads` — tell the user the link expires in **1 hour**. `landing_page_delete` soft-deletes the page but **preserves all lead data**.

19. 19. Connect a custom domain: `landing_page_connect_domain` → `landing_page_verify_domain` → serve

    Once the landing page is live, call `landing_page_connect_domain` (25¢) with a fully-qualified `domain` (e.g. `acme.com`) — this registers the mapping and kicks off a Fly Let's Encrypt cert. The domain starts in `pending` state. Poll `landing_page_verify_domain` (free) with the same domain to check cert provisioning; once ready, the mapping flips to `verified` and landing pages start serving from the custom host. `landing_page_list_domains` (free) shows all domains with current verification status. `landing_page_disconnect_domain` (free) removes the cert and stops serving. Mention the 25¢ cost on connect before running.

20. 20. Generate ad creative with `startup_generate_ad_asset` ($1/image)

    Pass a `prompt` (image description) plus optional `inspiration_image_urls` (up to 5 reference ads for style) and `brand_image_urls` (up to 5 brand assets — logos, product shots). Control output with `aspect_ratio`, `image_size` (1K/2K/4K), and `count` (1-10 images). Pick the backing model with `image_model`: `nano_banana` (default) is faster and cheaper; `gpt_image_2` is stronger on text rendering and brand consistency. When you use `gpt_image_2`, `quality` (`low`/`medium`/`high`/`auto`) tunes fidelity vs. speed; **it defaults to `medium` to keep OpenAI costs in check — pass `high` explicitly for hero or final creative.** `quality` is ignored on the `nano_banana` path, and unknown `image_model` values fall back to `nano_banana` silently so existing calls are unaffected. Billed **per image** at $1.00 each (min $1.00) — confirm `count` before firing. Pass `webhook_url` to run async.

21. 21. Browse Meta ad accounts with `meta_get_ids` and `meta_get_pages` (free)

    Navigate top-down with `meta_get_ids`: `level: "adaccounts"` → `"campaigns"` (with `parent_id`) → `"adsets"` → `"ads"` → `"adcreatives"`. Pass `date_preset` or `time_range` to include spend inline. `meta_get_pages` lists Facebook Pages connected to the authenticated user — you'll need a page_id for ad creation. **Critical**: all Meta IDs must be passed as **quoted strings** — bare numbers get rounded and silently mis-target.

22. 22. Pull insights with `meta_fetch_insights` (10¢/call)

    Query ad performance with `level` (`campaign`/`adset`/`ad`), `ids` as a comma-separated quoted string, and either `date_preset` OR `time_range` (never both). Add `breakdowns` like `"age,gender"` when the user wants slices. Default `fields` cover impressions, spend, clicks, CTR, actions, conversions — only override when the user specifies. Mention the 10¢ cost before running many calls in a row.

23. 23. Launch Meta campaigns: campaign → adset → image ad

    `meta_create_campaign` (free) is created in `PAUSED` status with `OUTCOME_SALES` by default — never un-pause automatically. Budgets are in **cents as quoted strings** (`"500000"` = $5,000). `meta_create_adset` (free) holds the targeting (geo, age, interests) and inherits CBO budget from the campaign (or sets its own). Upload imagery first with `meta_upload_image` (free, needs a publicly accessible URL) to get an `image_hash`. Then `meta_create_image_ad` ($1/call) combines the hash with copy, CTA, and landing page URL — Advantage+ enhancements auto-disabled. Confirm all inputs before firing the $1 call.

24. 24. Connect Google Ads with `google_ads_connection_status`, `google_ads_list_accessible_customers`, `google_ads_select_account`

    Start with `google_ads_connection_status` (free) to see whether the org has a Google Ads OAuth connection and which customer is currently selected. `google_ads_list_accessible_customers` (free) returns every account the connected credentials can reach, enriched with name, currency, time zone, manager flag, and status — agents should filter to `status == 'ENABLED' && manager == false` for accounts that can actually serve ads. Switch the active account with `google_ads_select_account` (free) by passing `selectedCustomerId` and, when the account sits behind an MCC, `loginCustomerId` (the manager ID). After saving, the tool runs a smoke GAQL query and returns `verified: true` on success or `verified: false` plus `verificationError` — check this before making real billable calls.

25. 25. Mine keyword ideas with `google_ads_generate_keyword_ideas` (25¢/call)

    Pass `keywords` (seed terms), `pageUrl` (landing page to mine), or both — plus optional `language` (default `en`), `geoTargetLocations` (default `['US']`, accepts 2-letter country codes or `geoTargetConstants/{id}`), `network`, and `pageSize`. Returns Google Keyword Planner data: per-keyword average monthly searches, competition level, and top-of-page bid range. Use the output to seed campaigns and ad groups before any spend.

26. 26. Build a Google Ads search campaign top-down (25¢ per creation step)

    Bottom-up sequence: `google_ads_create_campaign_budget` (sets the daily `amountMicros` — `1 USD = 1,000,000` micros; ⚠️ confirm the digit count out loud when ≥ $100/day) → `google_ads_create_search_campaign` (references the budget; pass `geoTargetLocations` and `language` or it serves globally, defaults `containsEuPoliticalAdvertising` to `DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING`, defaults to `PAUSED`) → `google_ads_create_ad_group` (PAUSED, sets a default CPC bid via `cpcBidMicros`) → `google_ads_create_responsive_search_ad` (3–15 headlines ≤30 chars, 2–4 descriptions ≤90 chars; `path1`/`path2` are **cosmetic display-URL breadcrumbs only** — they don't need to match real routes on `finalUrls`) → `google_ads_add_keywords` (1–200 per call, with BROAD/PHRASE/EXACT match types). Use `google_ads_add_negative_keywords` to exclude queries at campaign or ad-group level. **All resources start PAUSED** — flipping to ENABLED via `google_ads_update_campaign_status` / `update_ad_group_status` / `update_ad_status` requires `confirmEnableSpend: true`. `REMOVED` is irreversible and requires `confirmRemove: true` — prefer PAUSED if the user just wants to stop spend.

27. 27. Pull Google Ads performance and an AI narrative

    Structured reports (15¢/call each): `google_ads_get_campaign_performance` (impressions, clicks, cost, conversions, CTR, CPA, ROAS grouped by campaign), `google_ads_get_ad_group_performance`, `google_ads_get_keyword_performance` (includes quality score), `google_ads_get_search_terms_report` (actual user queries that triggered ads — gold for negative-keyword candidates). For anything custom, run `google_ads_run_gaql_query` (15¢/call, capped at 1000 rows) with a raw GAQL string. When the user wants a written takeaway, `google_ads_analyze_campaign` (50¢) pulls the requested period and the prior equivalent period, then returns an AI-narrated comparison with winners, losers, and concrete recommendations. Update budgets and bids with `google_ads_update_campaign_budget` and `google_ads_update_ad_group_bid` (25¢ each) — both take `amountMicros` / `cpcBidMicros` in micros, so confirm the digit count when amounts get large.

28. 28. Recall cross-conversation memory with `startup_recall_memory` (free)

    Vector-search the org's `org_memory` table — populated automatically from Slack and Telegram threads the agent has been part of. Pass a natural-language `query` (e.g. 'what did we decide about pricing last week?', 'what has the team said about onboarding?') and an optional `limit` (default 10, max 50). Filter scope with `surface` (slack/telegram), `role` (`user` for human turns, `assistant` for agent replies), `since`/`until` (ISO dates — useful when the user says 'last week' or 'in March'), and `thread_key` to pin to a single thread. Returns rows ranked by semantic relevance with `text`, `role`, `surface`, `thread_key`, `agent_name`, `created_at`, and `similarity_score`. Use this when the current conversation lacks context the user is referring to.

29. 29. Track progression with `startup_update_idea_status` and `startup_list_ideas` (free)

    Use `startup_update_idea_status` to move an idea through the lifecycle: `exploring` → `validated` → `active` (this is the one you're building!) → `paused` (didn't work out, revisit later). Pass the `idea_slug` plus the target `status`. `startup_list_ideas` returns every idea in your org with current status and tool-result counts; pass `include_paused: true` to surface shelved ones.

30. 30. Retrieve and export results (all free)

    `startup_get_results` returns saved output for a given `idea_slug`, newest-first — pass `toolName` to filter (e.g. only `startup_generate_names` runs) and `limit` (1-50). `research_get_results` does the same for web/Reddit runs. `startup_export_report` renders any saved result as a markdown document with a permanent download link — pass a specific `resultId`, or `idea_slug` + `toolName` to export the most recent of that type.

31. 31. Async via webhook_url (optional but recommended)

    `startup_validate_business_idea`, `startup_generate_names`, `startup_research_competitors`, `startup_generate_brand_identity`, and `startup_generate_ad_asset` each accept `webhook_url`. Without it, the tool blocks 30-90 seconds waiting on Gemini (or longer for batch image generation). With it, the tool returns immediately with `{ job_id, status: "processing" }` and POSTs the result to your webhook when done. Webhook payload: `{ job_id, tool_name, status: "completed" | "failed", result_data?, error? }`.

6. Tool Reference

70 tools, rendered live from the Gentic MCP manifest. Parameter tables come directly from each tool's JSON Schema.

7. Pricing

Pricing is pulled live from the Gentic MCP manifest. All prices are per call and deducted from your Gentic credits.

8. Notes

• Most tools require an `idea_slug`. Call `startup_create_idea` first, then reuse the same slug across research, validation, naming, domains, competitors, brand identity, landing pages, and ads so results accumulate against one idea.
• Ideas flow through four statuses: `exploring` → `validated` → `active` → `paused`. Use `startup_update_idea_status` to move between them and `startup_list_ideas` to see the whole portfolio (pass `include_paused: true` to include shelved ones).
• `startup_save_research_note` is free and append-only — use it whenever the agent has synthesized something worth keeping (supplier intel, founder quotes, tagline drafts, packaging hooks). Markdown body is stored on S3 as a canonical artifact and a row is written to `startup_results`, so notes show up in `startup_get_results` and count toward `startup_list_ideas.result_count`. To revise a note, save a new one rather than expecting an in-place edit.
• Custom domains go through two steps: `landing_page_connect_domain` (25¢) registers the mapping and starts Fly cert provisioning in `pending` state; `landing_page_verify_domain` (free) polls until the cert is issued and flips the mapping to `verified`.
• Built for bootstrappers — solo founders, side-project builders, small e-commerce brands, home-based businesses, vibe-coders. Not tuned for VC-backed growth stories.
• Trademark and cross-language linguistic checks from AI are **directional, not definitive**. Always verify independently before committing to a name.
• Seven tools (`startup_validate_business_idea`, `startup_generate_names`, `startup_research_competitors`, `startup_generate_brand_identity`, `startup_generate_ad_asset`, `startup_extract_brand_guidelines`, `landing_page_generate`) accept `webhook_url` for async execution — pass one to avoid blocking on Gemini / image generation / brand crawling / Opus landing-page generation.
• `startup_extract_brand_guidelines` costs **$3/call** (async) and writes a canonical brand document keyed by domain. `startup_get_brand_guidelines` is always free for subsequent reads — extract once per brand, reuse everywhere.
• `startup_check_domain_availability` is backed by Name.com's live pricing API — prices reflect actual registrar costs at the moment of the call.
• Landing pages deploy to `{subdomain}.gentic.run/{page-slug}`. Every org gets its original slug auto-claimed as a default subdomain; additional brand hosts can be reserved with `landing_page_claim_subdomain`. Deploy precedence when no `subdomain` is passed: explicit input → idea's auto-claimed subdomain → org default. The `url` and `subdomain` fields on every deploy/list/replace/get response reflect the actual host — never reconstruct URLs from `org_slug + slug`.
• **Generate-then-promote is the cheapest path for landing pages.** `landing_page_generate` ($7.50, async via Claude Opus 4.7, charged only on success) writes an immutable draft and returns a `draft_id`. Promote with `landing_page_deploy(draft_id=...)` or `landing_page_replace(draft_id=...)` for **25¢** instead of $7.50. The legacy raw-html path still works at $7.50 — only use it when you already have hand-written markup. On the raw-html path, HTML must be **complete and self-contained** (inline all CSS/JS); generated drafts already are. Setting `reference_url` adds a **10¢** surcharge — the server auto-fetches the rendered source via ScrapingBee so the model has HTML to clone (same price as `fetch_rendered_page`); pass `base_html` instead if you've already fetched the source yourself. Pass `webhook_url` to receive a POST when the job completes.
• **Three tiers for editing a live page, by intent and cost.** `landing_page_patch` (50¢) — mechanical string replacement when you already know the exact old/new strings (typos, image swaps, color tweaks). `landing_page_edit` ($1) — describe the change in prose and Gemini computes the minimal diff ("add a testimonial section after the hero", "remove the pricing block"). `landing_page_replace` (25¢ from a draft, $7.50 raw) — layout changes and full rewrites only.
• **Every landing-page change is versioned.** `deploy`, `replace`, `patch`, and `restore` each write an immutable version row. List with `landing_page_list_versions` (free), inspect any historical HTML via `landing_page_get_version` (free), roll back with `landing_page_restore_version` (25¢) — restores create a new version rather than overwriting history, so they're themselves reversible.
• `startup_create_idea` best-effort auto-claims a brand subdomain matching the idea name and attaches it to the idea row. If auto-claim is skipped, the response includes `subdomain_auto_claim_reason` (`reserved` / `invalid_base` / `matches_default` / `all_suffixes_taken` / `cap_reached` / `attach_failed`) — handle it by suggesting `landing_page_claim_subdomain` with a different label. Use `startup_update_idea_subdomain` to swap the attached subdomain when the user pivots the brand name before deploying.
• Slug uniqueness on landing pages is **scoped per subdomain** — the same path slug (e.g. `/launch`) can exist on two different brand subdomains without collision.
• Always call `landing_page_get_html` before `landing_page_patch` and pass the returned `content_hash` as `expected_content_hash` to avoid clobbering concurrent edits.
• Lead capture is built in at `POST /api/leads/:orgSlug/:pageId`. Soft-deleted pages preserve lead data. CSV export links expire in **1 hour**.
• All Meta IDs (ad account, campaign, adset, ad, creative) must be passed as **quoted strings** — JavaScript rounds large integers and causes silent mis-targeting. Budgets are in **cents as quoted strings** (`"270000"` = $2,700).
• All Meta campaigns, ad sets, and ads default to `PAUSED` — never un-pause automatically. Advantage+ creative enhancements are auto-disabled on `meta_create_image_ad` for full control.
• `startup_generate_ad_asset` is billed **per image** at $1.00 (min $1.00). Confirm `count` before running — a 10-image batch is $10.
• Google Ads campaigns, ad groups, and ads also default to `PAUSED`. Flipping to `ENABLED` via `google_ads_update_campaign_status` / `update_ad_group_status` / `update_ad_status` requires `confirmEnableSpend: true`. `REMOVED` is **irreversible** in Google Ads (no restore) and requires `confirmRemove: true` — prefer `PAUSED` if the user only wants to stop serving.
• Google Ads budgets and bids use **micros** (1 USD = 1,000,000 micros). `amountMicros` ≥ 100,000,000 ($100/day) and `cpcBidMicros` > 20,000,000 ($20/click) are typo-prone — confirm the dollar amount with the user before submitting. New campaigns must declare `containsEuPoliticalAdvertising` (defaults to `DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING`); only flip when the campaign actually runs EU political ads. Pass `geoTargetLocations` and `language` on `google_ads_create_search_campaign` or it serves globally in all languages.
• RSA `path1`/`path2` are **cosmetic display-URL breadcrumbs only** — they render as `example.com/{path1}/{path2}` in the ad and do not need to match a real route on `finalUrls`. Don't fabricate paths that imply sections that don't exist.
• `startup_recall_memory` is free and reads from the org-scoped `org_memory` table populated automatically by Slack/Telegram capture. Use it when the user references prior decisions or threads the current conversation doesn't contain. Filter with `surface`, `role`, `since`/`until`, or `thread_key` to keep results tight.
• All tools are organization-scoped — users only see their own ideas, research, landing pages, leads, custom domains, ad accounts (Meta + Google), and memory rows.