# Brand Naming Agent: agent guide From a one-line description, AI fills in the kind of name, category, home or global use, customer and values, then makes 10 names from ListeningMind search data (volume, journeys, related searches, Google AI Overviews, community posts) and a 9-language root library. It drops names already in use, look-alikes of existing brands in any field and names with bad meanings in other languages, runs a Gemini/ChatGPT first-impression test and domain checks, and gives each name a promise, story, purpose statement and manifesto. Used by brand managers and founders. Markets: Korea, Japan, US. ## Connect - MCP: `https://daas-naming.listeningmind.ai/mcp` (Streamable HTTP). Start with `app_guide`. - Browser agents: tools are registered on every page through WebMCP (`document.modelContext`). - REST: `https://daas-naming.listeningmind.ai/.well-known/openapi.json` ## Approval - read and action tools run at once. - run and delete tools need a person's approval. Over MCP the tool returns `confirm_url`; show it to the person, then call `confirmation_status` with the token until state is done. - In the browser the page shows the person a confirm box. ## Workflow 1. `ask_llm` (run): If only a description is given, extract 2-4 category keywords with keywordExtractionPrompt. 2. `check_intel_cache` (read): Check whether the data is cached (0 credits). 3. `get_market_intel` (run): Collect the search evidence; with no data the UI falls back to LLM-estimated journeys. 4. `ask_llm` (run): Build the strategy brief with briefPrompt citing evidence ids (plus translationPrompt for the foreign style). 5. `ask_llm` (run): Generate a candidate pool per naming route with poolPrompt. 6. `check_name_usage` (run): Check whether candidates are already in use by search volume and .com. 7. `ask_llm` (run): Critique similarity and distinctiveness with criticPrompt (prefer=openai); repeat pool, check, critic up to 3 rounds until the target count is met. 8. `ask_llm` (run): Explain and score the selected names in chunks of 4 with detailPrompt. 9. `check_domains` (read): Check domain status for each name across the market TLD list. 10. `ask_llm` (run): Optionally deep-check chosen names (competitors, trademark risk, SNS, SEO, verdict). ## Inputs A one-line business or product description (required). Everything else is optional and guessed by AI when empty: kind of name (company, product, service, store), category, home or global use, customer, market (kr/jp/us), tones, naming styles (coined, compound, real word, foreign roots, name from a story, acronym), brand purpose (cause, strength/passion/need, desired impact, archetype, personality axes), script, length, required word, words to avoid, preferred TLDs, deep analysis. ## Outputs 10 names (+5 per request, including variations of liked names). Per name: spelling, romanized, route, one-line summary, customer quote and search signal, evidence, etymology, story source; an availability score (search volume, look-alike brands, domains, pronunciation, deep check, meaning in other languages, first-impression test); its promise, three jobs of a name, golden circle, challenger line, purpose statement and manifesto; background story, visual direction, palette and photo ideas. Plus the strategy brief, the 9-language root table, a purpose diagram, shortlist compare / PDF / CSV, saved results (/r/) and share links. ## Cost and time One generation makes about 15-22 LLM calls (profile 1, brief 1, roots 1, candidate pool 1-3 rounds, critic 1-3, details 4, first-impression test 4, other-language meanings 1, deep checks 3-5, meaning 1) and one ListeningMind data collection. Data credits are usually 1,200-2,500 (11,000-16,000 with deep analysis, which adds cluster_finder) and 0-400 when the same keywords ran in the last 24 h. Checking a name against stored Google results costs 30 per name. Domain checks are free. Usually 2-3 minutes. ## Limits The naming pipeline (evidence, prompts, selection, scoring) runs in the browser via /naming-core.js; the server collects data, relays LLM calls, checks names, domains and stored Google results, and saves results. To reproduce a UI result an agent follows the prompt builders in /naming-core.js (keywordExtractionPrompt, briefPrompt, rootsPrompt, poolPrompt, criticPrompt, detailPrompt, perceptionPrompt, langCheckPrompt, deepCheckPrompt, meaningPrompt) and its scoring (scoreParts). Finished results are saved per member with save_run and reopen at /r/. Markets: kr, jp, us. ## Method (how the analysis works) 1. Guess search keywords and the naming brief (kind of name, category, home/global, customer, tone, styles, purpose) from one line; the user corrects it on the next screen. 2. Collect ListeningMind evidence: search volume, journeys, related searches, Google AI Overviews and community posts. 3. Write a brief citing the evidence and, in parallel, expand the core ideas into words and roots in 9 languages. 4. Generate candidates through several naming routes and drop names by search volume, .com, look-alike brands in any field and bad meanings in other languages (up to 3 rounds). The same request keeps about 65% of its previous names. 5. Explain the chosen 10, check domains and alternatives, run a Gemini/ChatGPT first-impression test, meanings in 10 languages, stored Google results and a deep check of the top names, re-rank, then write the meaning (promise, purpose, manifesto) of the top 3. ## Reading the result - Read the brief first: consumer words, needs, moments, white space and cliches explain why the names point where they do. - Each recommended name has its route, evidence, tagline, Keller 6-criteria scores, trademark strength and persona fit. - In the name check, 100 or more monthly searches means the name is already in use; com_available and the per-TLD domain status show what can be registered. - The trademark view is a critic model's judgement of similarity; the deep check of chosen names adds competitors, trademark risk, SNS handles, SEO and a verdict. - Results exist only in the open browser tab and the CSV, so save them yourself. ## Requests this app answers well - Recommend about 8 brand names for a pet supplement, grounded in search data - Name a cafe brand for Japan in Katakana and check whether the domains are free - Check whether these name candidates are already in use, by search volume and .com - Name a skincare brand for the US in a warm, premium tone and check the trademark risk ## Continue in another app - [ICSS](https://daas-icss.listeningmind.ai/llms.txt) (MCP `https://daas-icss.listeningmind.ai/mcp`): When you want to compare the shortlisted names with a synthetic consumer panel before real research. Carry: The shortlisted names with their taglines as compare candidates ('name :: description'), plus the category keyword and market. ## Using the screens (browser agents) - `describe_screen`: menus, tabs, fields and buttons of the current screen, and what the page is for - `go_to`: open a menu or page of this app by its label or path - `fill_field`: type a value into a field by its label (never presses run; runs go through the run tools, which ask the person) - `read_this_page`: the text and ids of what the person is looking at ## The ListeningMind apps (same account, same tools, call any of them) Each app has `/mcp`, `/llms.txt`, `/agents.md` and WebMCP on its pages. `family_apps` and `recommend_app` return this list with addresses. - [ACO](https://daas-aco.listeningmind.ai/llms.txt): Diagnoses whether a product detail page can be cited by AI answers and used by shopping agents (MCP `https://daas-aco.listeningmind.ai/mcp`) - [AOO](https://daas-aoo.listeningmind.ai/llms.txt): Measures whether AI agents can get real tasks done on a website (MCP `https://daas-aoo.listeningmind.ai/mcp`) - [Brand Finder](https://daas-brand.listeningmind.ai/llms.txt): Which brands lead search by generation or field, and what their brand assets are (MCP `https://daas-brand.listeningmind.ai/mcp`) - [Brand Wiki](https://daas-wiki.listeningmind.ai/llms.txt): Turns a brand website into the entities, wiki pages and evidence AI assistants read (MCP `https://daas-wiki.listeningmind.ai/mcp`) - [CEP Finder](https://daas-cep.listeningmind.ai/llms.txt): In which situations do people start looking for this category (category entry point map) (MCP `https://daas-cep.listeningmind.ai/mcp`) - [Creative Finder](https://daas-creative.listeningmind.ai/llms.txt): Finds purchase situations (CEP) in search data and drafts a creative, an image and a video for each (MCP `https://daas-creative.listeningmind.ai/mcp`) - [Demand Forecast](https://daas-forecast.listeningmind.ai/llms.txt): What category demand looks like in the next 3-6 months and when to launch or campaign (MCP `https://daas-forecast.listeningmind.ai/mcp`) - [Funnel Leak Finder](https://daas-funnel.listeningmind.ai/llms.txt): Where category search journeys leak to competitors (MCP `https://daas-funnel.listeningmind.ai/mcp`) - [GEO Audit](https://daas-geo.listeningmind.ai/llms.txt): Checks whether a web page is ready to be read and cited by search engines and AI answer engines (MCP `https://daas-geo.listeningmind.ai/mcp`) - [ICSS](https://daas-icss.listeningmind.ai/llms.txt): Synthetic consumer panel conditioned on search intent, for surveys and FGDs (MCP `https://daas-icss.listeningmind.ai/mcp`) - [Intent KG](https://daas-intent.listeningmind.ai/llms.txt): What people look for about a topic, why, and how they choose (Intent Knowledge Graph) (MCP `https://daas-intent.listeningmind.ai/mcp`) - [Prompt Builder](https://daas-prompt.listeningmind.ai/llms.txt): Finds what consumers ask AI and builds managed brand prompts with AI visibility (MCP `https://daas-prompt.listeningmind.ai/mcp`) - [Pulse Finder](https://daas-pulse.listeningmind.ai/llms.txt): What is rising in search for a gender and age segment right now (MCP `https://daas-pulse.listeningmind.ai/mcp`) - [Smart Store Suite](https://daas-store.listeningmind.ai/llms.txt): Which Smart Store products to grow, and how to rewrite their titles and detail pages in searchers' words (MCP `https://daas-store.listeningmind.ai/mcp`) - [Taste Finder](https://daas-taste.listeningmind.ai/llms.txt): In what sensory and emotional words do people choose this (consumer taste report from search data) (MCP `https://daas-taste.listeningmind.ai/mcp`) - [ListeningMind Data API](https://daas.listeningmind.ai/llms.txt): the search data behind every app (MCP `https://daas.listeningmind.ai/mcp`) · [glossary](https://daas.listeningmind.ai/en/glossary) · [all apps](https://daas.listeningmind.ai/en/apps) ## Run stages - `evidence`: Building evidence - `brief`: Customer words and brief - `roots`: Roots in 9 languages - `pool`: Generating candidates - `check`: Checking name usage - `critic`: Removing look-alikes - `detail`: Explaining and domains - `verify`: Impression test and risk check - `meaning`: Shaping each name's meaning ## All tools ### check_intel_cache Tells whether the expensive search data (path_finder and cluster_finder) for the first keyword is already cached on the server, so get_market_intel would cost 0 credits. Returns {cached, primary, gl}. Also returns estimate:[low, high] data credits for this run. Read only, free. Usually followed by: get_market_intel. `POST /api/intel-status` - `keywords` (required): Category search keywords; the first one is checked. - `market`: Target market. - `lang`: UI language code of the app (kr = Korean, jp = Japanese, en = English); sets the language of summaries. - `deep`: ### get_market_intel Collects the ListeningMind evidence used for naming, for up to 3 category keywords: keyword_info (volume, trend, competition, CPC, intents, demography), path_finder search journeys, cluster_finder communities (first keyword), intent_finder related searches with their volumes, and stored Google SERPs (AI Overview, People Also Ask, top sites) for up to 2 keywords. Every piece is cached on disk for 24 hours. Returns {keyword_info, paths, clusters, related, related_volumes, summaries, serp, source, errors, hasData}. Spends ListeningMind Data API credits or paid model calls. Over MCP a person approves it first (you get a confirm link); in the browser the page asks the person. Cost: ListeningMind Data API credits: keyword_info for up to 23 keywords, 1-2 path_finder, 1 cluster_finder (the costly one), 1 intent_finder, up to 6 SERP lookups; 0 when cached. Time: about 20-90 seconds. Usually followed by: ask_llm. `POST /api/intel` - `keywords` (required): 1 to 3 category search keywords (not brand names), most representative first. - `market`: Target market. - `lang`: UI language code of the app (kr = Korean, jp = Japanese, en = English); sets the language of summaries. - `deep`: Deep analysis: adds cluster_finder (about 10,000 more credits) and 50 journeys instead of 15. - `avoid`: Comma-separated words to avoid; consumer-voice queries containing them are skipped. ### ask_llm Sends one system+user prompt to the server LLM chain (Gemini first, OpenAI as fallback). The browser builds every naming prompt with the shared NamingCore library (/naming-core.js): keyword extraction, foreign-root translation, strategy brief, candidate pool, critic, detail and deep investigation. With json=true an answer that is not valid JSON counts as failure and the next provider is tried. Returns {text, provider, model, fallback, truncated?, invalid_json?}. Spends ListeningMind Data API credits or paid model calls. Over MCP a person approves it first (you get a confirm link); in the browser the page asks the person. Cost: one paid LLM call. Time: 5-120 seconds. `POST /api/llm` - `system`: System prompt. - `message` (required): User prompt. - `max_tokens`: Max output tokens (UI uses 1500-9000 by step). - `temperature`: Sampling temperature. - `json`: Require a JSON answer (UI always sends true). - `prefer`: Provider to try first, e.g. 'openai' for the critic so it runs on a different model than the generator. ### check_name_usage For up to 40 candidate names: monthly search volume of the romanized spelling, of the native spelling (if non-ASCII) and of ' ' for real-word names, plus whether .com is registered. High volume means the name is already in use. Returns {checks:{:{volume, native_volume, combo_query, combo_volume, com_available}}}. Spends ListeningMind Data API credits or paid model calls. Over MCP a person approves it first (you get a confirm link); in the browser the page asks the person. Cost: ListeningMind keyword_info, about 10 credits per uncached keyword (cached 24 h). Time: 5-30 seconds. `POST /api/name-check` - `items` (required): Candidates: [{name (native spelling), romanized (ASCII spelling), combo (category word, only for real-word routes)}]. - `market`: Target market. ### check_domains Checks up to 120 domains: registered if NS records exist, confirmed available by RDAP, A-record fallback. The UI checks each name against the market TLD list (kr: .ai .co .co.kr .kr .com .net .io; jp: .ai .co .jp .co.jp .com .net .io; us: .ai .co .com .net .io .me). Returns [{domain, available: true|false|null}]. Read only, free. Time: 2-20 seconds. `POST /api/check-domains-batch` - `domains` (required): Domain names like vitaru.com (letters, digits, dots, hyphens). ### check_domain Checks one domain the same way as check_domains. Returns {domain, available: true|false|null}. Read only, free. `POST /api/check-domain` - `domain` (required): Domain name, e.g. vitaru.ai. ### save_run Saves a finished result set (brands with scores, domain and deep-check data, brief, evidence) for the signed-in member; the page does this itself when generation and investigation finish. Pass id to update a run you saved earlier. Returns {id, path} where path is /r/. Changes saved data in the app; no credits. `POST /api/runs` - `id`: Existing run id to update (omit to create) - `input`: - `keywords`: - `market`: - `lang`: - `brands` (required): - `dm`: - `cm`: - `invData`: - `brief`: - `intel`: - `evidence`: ### list_runs The signed-in member's saved result sets, newest first: id, created_at, input, market, keywords, brands (count), top (first names). Open one at /r/ or read it with get_run. Read only, free. `GET /api/runs` ### get_run One saved result set in full (brands, dm domain checks, cm, invData deep checks, brief, intel, evidence). Only its owner can read it. Read only, free. `GET /api/runs/{id}` - `id` (required): ### check_name_serp For up to 5 candidate names: stored Google results for the bare name (ListeningMind store, so a never-searched name returns no hits). Returns {results:{:{query, hits:[{title,site,url}], exact (results carrying the name in title or domain), exact_hits, aio}}}. Spends ListeningMind Data API credits or paid model calls. Over MCP a person approves it first (you get a confirm link); in the browser the page asks the person. Cost: ListeningMind serp, 30 credits per name (cached 24 h). Time: 2-10 seconds. `POST /api/name-serp` - `names` (required): Candidates: [{name (native spelling), romanized (ASCII key)}], up to 5. - `market`: Target market. ### get_anchor The last names this member got for the same request (key = NamingCore.anchorKey(params)); the app keeps about 65% of them on a re-run. Returns {anchor:{at, brands, brief}|null}. Read only, free. Time: under 1 second. `POST /api/anchor/get` - `key` (required): NamingCore.anchorKey(params): normalized input, market, script, length, styles, required/avoided words, brand type, UI language. ### save_anchor Store the top 10 names (with _verdict) and the brief for the request key so the next run keeps about 65% of them. Spends ListeningMind Data API credits or paid model calls. Over MCP a person approves it first (you get a confirm link); in the browser the page asks the person. Time: under 1 second. `POST /api/anchor` - `key` (required): Same key as get_anchor. - `brands` (required): Final ranked names, top 10, each with _verdict (strong|caution|risky|null). - `brief`: The naming brief from this run (reused so kept names stay consistent). ### check_trademark Same or similar word marks in the Korean register (KIPRIS Plus, when the server has a key) plus prefilled links to KIPRIS, J-PlatPat, USPTO and WIPO. Returns {configured, results:[{title, applicant, status, classes, appNo, appDate, regNo, regDate}], links, errors}. Screening only, not legal advice. Read only, free. Cost: free (KIPRIS quota on the server key). Time: 1-20 seconds. `POST /api/trademark` - `name` (required): Name in its native spelling. - `romanized`: ASCII spelling. - `market`: Target market. ### start_tracking Register a launched name for monthly search-volume tracking (the name, its romanization and up to 3 ' ' phrases). Reads keyword_info now and once a month after. Returns {track:{id, keywords, runs, series}}. Spends ListeningMind Data API credits or paid model calls. Over MCP a person approves it first (you get a confirm link); in the browser the page asks the person. Cost: ListeningMind keyword_info, 10 credits per phrase now and once a month. Time: 2-10 seconds. `POST /api/track` - `name` (required): Name in its native spelling. - `romanized`: ASCII spelling. - `keywords`: Extra phrases to watch, e.g. ' '. - `market`: Target market. - `category`: Category label for display. - `run_id`: Saved result the name came from. ### list_tracks This member's tracked names with monthly volumes ({tracks:[{id,name,keywords,runs:[{at,vol,related}],series}]}). Read only, free. Time: under 1 second. `GET /api/tracks` ### stop_tracking Delete a tracked name owned by this member. Spends ListeningMind Data API credits or paid model calls. Over MCP a person approves it first (you get a confirm link); in the browser the page asks the person. Time: under 1 second. `POST /api/track/delete` - `id` (required): Track id from list_tracks.