Brand Naming Research

commands no always-loaded rules -- loads on demand updated 2026-08-04

Slash commands for brand naming research: /brand (full naming pipeline with word exploration, domain/trademark/app store checks) and /brand-check (single-name deep verification). Optionally adds Instant Domain Search MCP server for fast domain availability checks.

README

Brand Naming Research Module

Comprehensive brand naming research tools that automate the entire naming pipeline - from word exploration through domain, trademark, app store, and social media verification.

Commands

`/brand <concept description>`

Full naming research pipeline. Takes a concept description and produces a scored report with 150-250 name candidates.

Pipeline stages:

Word Exploration (4 parallel agents) - Datamuse API (synonyms, semantics, sounds-like), ConceptNet (conceptual relationships), Big Huge Thesaurus (synonym/antonym), LLM philosophical/etymological knowledge
Name Generation - 6 categories: single words, compounds, vowel-dropped, invented/neo-Latin, philosophical/classical, word+TLD combos
Domain Availability - Checks all candidates via Instant Domain Search MCP (or DNS/whois fallback)
Trademark Pre-Screen - USPTO/Marker API search for conflicts
App Store Check - iTunes Search API + Google Play web search
Social Handle Check - GitHub, Twitter/X, Instagram, Reddit, YouTube, TikTok, LinkedIn, Product Hunt
Scoring & Report - Weighted scoring on pronounceability, memorability, scope, domain availability, trademark clearance, social handles, story/meaning

Example:

/brand "AI-powered life framework for habits, goals, and principles"
/brand "developer tool for API testing" --tlds ai,io,dev,com

`/brand-check <name> [, name2, name3]`

Deep verification of one or more specific brand name candidates. Checks everything in detail for a single name.

Checks:

Domains across 12 TLDs (.ai, .io, .com, .life, .work, .app, .co, .dev, .org, .net, .me, .us) with pricing estimates
USPTO and WIPO trademark search
Apple App Store and Google Play name collisions
Social media handles on 8 platforms
Existing business/company web presence

/brand-check shells out to lib/brand-check-gather.sh (installed to ~/.claude/lib/brand-check-gather.sh) to run the DNS/whois/social checks concurrently; WebSearch-backed checks stay in the agent.

Example:

/brand-check lifebldr
/brand-check lifebldr, lifetenet, prosoche

MCP Server (Optional)

The installer's config prompt can guide you through adding the Instant Domain Search MCP server. Register it with:

claude mcp add --transport http --scope user instant-domain-search https://api.instantdomainsearch.com/mcp/streamable-http
claude mcp get instant-domain-search   # expect: Status: ✓ Connected

Free, no authentication required
Checks 800+ TLDs in under 25ms
Tools: search_domains, check_domain_availability, generate_domain_variations
Without this MCP, commands fall back to DNS + whois (slower but functional)

Free APIs Used

All APIs used by these commands are free with no authentication required:

API	Rate Limit	Used For
Datamuse	100,000/day	Synonyms, semantic similarity, sounds-like, hypernyms
ConceptNet	~5-10 req/sec	Conceptual relationships, semantic graph
Big Huge Thesaurus	10,000/day	Synonym/antonym pairs
iTunes Search	No published limit	Apple App Store name collision check
Instant Domain Search	No published limit	Domain availability (via MCP)

Manual Installation

Copy the command files and the /brand-check gather script to your Claude Code config directory:

mkdir -p ~/.claude/commands
cp commands/brand.md ~/.claude/commands/brand.md
cp commands/brand-check.md ~/.claude/commands/brand-check.md
mkdir -p ~/.claude/lib
cp lib/brand-check-gather.sh ~/.claude/lib/brand-check-gather.sh

Optionally register the MCP server:

claude mcp add --transport http --scope user instant-domain-search https://api.instantdomainsearch.com/mcp/streamable-http

Restart Claude Code for the MCP server to load.

Will install

Path	Action	Target	Type
`commands/brand.md`	→	`commands/brand.md`	command
`commands/brand-check.md`	→	`commands/brand-check.md`	command
`lib/brand-check-gather.sh`	→	`lib/brand-check-gather.sh`	lib

Dependencies

No dependencies.

Required by

No other module depends on this one.

Asks during install

Register Instant Domain Search MCP server via `claude mcp add --scope user`? (Recommended - free, no auth, 800+ TLDs, sub-25ms checks)

Default: yes

Options: yesno

Included in presets

Install this module

Agent prompt

Recommended for agent users -- hands the whole install off to your assistant.

Fetch https://cd23a9be.ccgm-site.pages.dev/modules/brand-naming.md and install this module into my Claude Code setup.

Native plugin marketplace

One command via the native plugin marketplace -- additive, does not merge settings.json.

claude plugin install brand-naming@ccgm

The marketplace path is additive, not a replacement: it installs commands, agents, and skills as native plugin components, but it does not perform the bash installer's deep settings.json merge, and it does not write the always-loaded global CLAUDE.md context. Rules are only injected via an opt-in SessionStart hook rather than being auto-loaded. Use the bash installer when those pieces matter to you.

Manual, per file

Full control -- copy exactly the files you want from the sections below.

Files

command (2)

commands/brand.md

---
description: Comprehensive brand naming research - word exploration, name generation, domain/trademark/app store/social checks
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, Agent, WebSearch, WebFetch, AskUserQuestion, TaskCreate, TaskUpdate, TaskList
argument-hint: <concept description> [--tlds ai,io,com,life] [--output <path>]
---

# /brand - Brand Naming Research Pipeline

A comprehensive naming research system that explores word spaces, generates creative name candidates, and validates availability across domains, trademarks, app stores, and social media.

## Sub-Agent Model Optimization

When spawning sub-agents, use cheaper models to conserve usage:

| Phase | Sub-Agent | Model |
|-------|-----------|-------|
| Phase 1 | Word exploration agents (Datamuse, ConceptNet, Thesaurus, Philosophical) | haiku |
| Phase 3 | Domain availability checking | haiku |
| Phase 4-5 | Trademark, app store, social checks | haiku |

The orchestrator remains on the current model for name generation (Phase 2) and scoring/synthesis (Phase 6), which require creative judgment.

---

## Input

```
$ARGUMENTS
```

---

## Phase 0: Parse Input & Setup

### 0.1 Parse Arguments

Extract from `$ARGUMENTS`:
- **Concept description**: What the product/brand is about. Can be a sentence, paragraph, or set of keywords.
- **`--tlds <list>`**: (Optional) Comma-separated TLDs to check. Default: `ai,io,com,life,work`
- **`--output <path>`**: (Optional) Where to write the final report. Default: `~/code/docs/brand-research/brand-research-{descriptive-slug}.md`
- If no arguments provided, use AskUserQuestion to ask what the user wants to name.

### 0.2 Gather Preferences

Use AskUserQuestion to ask (skip if concept description is very detailed). Structure the call exactly as follows - every option MUST have both `label` and `description` fields, and each question must have 2-4 options:

**Question 1** - Naming style (multiSelect: true, header: "Style"):
- label: "Modern/tech", description: "Vowel-dropped or abbreviated words (lifebldr, Flickr, Grindr style)"
- label: "Classical/invented", description: "Philosophical, neo-Latin, or invented words rooted in etymology (prosoche, telara)"
- label: "Compound", description: "Two real words combined into a brand (lifealign, dailycraft, deepwork)"
- label: "Single word", description: "One real English word as the brand (flint, cadence, meridian)"

**Question 2** - TLD preference (multiSelect: false, header: "TLD"):
- label: ".com", description: "Most recognizable and trusted, but hardest to find available"
- label: ".ai", description: "Strong for AI/tech products, growing recognition"
- label: ".io", description: "Popular with developers and tech startups"
- label: "No preference", description: "Optimize for the best available name regardless of TLD"

### 0.3 Set Up Output

Create a working directory for intermediate results:
```bash
WORK_DIR="/tmp/brand-research-$(date +%s)"
mkdir -p "$WORK_DIR"
```

---

## Phase 1: Word Exploration (Parallel Agents)

Launch 4 parallel agents to explore the word space. Each agent writes results to `$WORK_DIR/`.

> **Concurrency:** four `haiku` agents in one wave is well within the safe band — keep the model light and the count at 4. See `~/.claude/rules/concurrency-and-rate-limits.md`.

### Agent 1: Datamuse Semantic Explorer

Query the Datamuse API for each key concept word in the user's description. Use these endpoints (no auth needed):

```bash
# Synonyms
curl -s "https://api.datamuse.com/words?rel_syn=WORD&max=50"

# Meaning-related (semantic similarity via word2vec)
curl -s "https://api.datamuse.com/words?ml=WORD&max=50"

# Trigger words (statistically associated)
curl -s "https://api.datamuse.com/words?rel_trg=WORD&max=50"

# Sounds like (for creative spelling variants)
curl -s "https://api.datamuse.com/words?sl=WORD&max=20"

# Hypernyms ("kind of")
curl -s "https://api.datamuse.com/words?rel_spc=WORD&max=30"

# Hyponyms ("more specific than")
curl -s "https://api.datamuse.com/words?rel_gen=WORD&max=30"
```

Extract key concept words from the description first. For example, "life operating system for habits, goals, and principles" yields: life, habit, goal, principle, system, routine, discipline, foundation, build, guide, framework.

Write results to `$WORK_DIR/datamuse-results.json`.

### Agent 2: ConceptNet Relationship Explorer

Query ConceptNet for conceptual relationships (no auth needed):

```bash
# Related concepts
curl -s "https://api.conceptnet.io/related/c/en/WORD?limit=30"

# Edges (relationships)
curl -s "https://api.conceptnet.io/c/en/WORD?limit=30"
```

Focus on relationships: IsA, PartOf, HasProperty, RelatedTo, DerivedFrom, EtymologicallyRelatedTo.

Write results to `$WORK_DIR/conceptnet-results.json`.

### Agent 3: Big Huge Thesaurus Deep Synonyms

Query the Big Huge Thesaurus for pure synonym/antonym data (no auth needed for <10k/day):

```bash
curl -s "https://words.bighugelabs.com/api/2/YOUR_API_KEY/WORD/json"
```

Note: If no API key, fall back to Datamuse synonyms (already covered by Agent 1). The API key is free to obtain but optional. Without it, use this alternative for additional synonym coverage:

```bash
# Use the free dictionary API as a supplement
curl -s "https://api.dictionaryapi.dev/api/v2/entries/en/WORD"
```

Write results to `$WORK_DIR/thesaurus-results.json`.

### Agent 4: Philosophical & Etymological Explorer

This agent does NOT call APIs. It uses the LLM's knowledge to generate:

1. **Greek philosophical terms** related to the concept (Stoic, Aristotelian, Platonic, pre-Socratic)
2. **Latin roots** related to the concept
3. **Sanskrit/Pali/Buddhist terms** related to the concept
4. **Japanese concepts** (ikigai, kaizen, etc.) related to the concept
5. **Etymology chains** - trace key words back to their Proto-Indo-European or Latin/Greek roots
6. **Mythological references** - names from Greek, Norse, Hindu, Celtic mythology that embody the concept
7. **Literary/philosophical references** - names from notable works, thinkers, traditions

For each term, include: the word, pronunciation guide, origin language, meaning, and why it maps to the concept.

Write results to `$WORK_DIR/philosophical-results.md`.

---

## Phase 2: Name Generation

After all Phase 1 agents complete, read all result files and generate name candidates.

### 2.1 Compile Word Pool

Merge and deduplicate all words from Phase 1 into a master word pool. Categorize:
- **Core concept words** (from user description)
- **Synonyms & related** (from Datamuse/Thesaurus)
- **Conceptual associations** (from ConceptNet)
- **Philosophical/classical** (from Agent 4)

### 2.2 Generate Name Candidates

Using the word pool and user's style preferences, generate candidates in these categories:

**Category A: Single Real Words**
- Select the strongest single words from the pool that could stand alone as brand names
- Prioritize: short (<10 chars), uncommon but pronounceable, evocative

**Category B: Compound Words**
- Combine pairs from the word pool (e.g., lifethread, truepath, deepwork)
- Prefer: first word is concept anchor, second word is action/quality

**Category C: Vowel-Dropped / Abbreviated**
- Take strong compounds and drop vowels or abbreviate (lifebldr, lifecrft, lifshpr)
- Follow patterns: Flickr (-er to -r), Tumblr (-er to -r), Grindr

**Category D: Invented / Neo-Latin**
- Create novel words rooted in real etymological stems
- Pattern: [root] + [-ara, -is, -ia, -on, -os, -eia, -ium] (e.g., telara from telos, prokopia from prokope)
- Must be pronounceable and suggest meaning

**Category E: Philosophical / Classical**
- Select the best terms from Agent 4's output
- Include pronunciation guide for each
- Prioritize: pronounceable on first read > deeply meaningful but unpronounceable

**Category F: Word + TLD combos**
- Names that work as word.tld (e.g., build.life, deep.work)
- Short words that gain meaning from the TLD

Target: **150-250 total candidates** across all categories.

Write the full candidate list to `$WORK_DIR/candidates.txt` (one per line, no TLD).

---

## Phase 3: Domain Availability Check

**CRITICAL: DNS alone is NOT sufficient to determine domain availability.** Many domains are registered but parked without DNS records (no A record). A domain with no DNS response can still be registered and locked down. The ONLY reliable check is whois registration lookup.

### 3.1 Check via Instant Domain Search MCP

If the `instant-domain-search` MCP tools are available, use them:

1. **`search_domains`** - Pass candidate names to get bulk availability across TLDs
2. **`check_domain_availability`** - Verify top candidates definitively

### 3.2 Two-Step: DNS Pre-Filter + Whois Verification (MANDATORY)

If MCP tools are unavailable, use a two-step process. Both steps are required.

**Step 1: DNS pre-filter (fast, parallel, but unreliable)**

Use DNS to quickly eliminate domains that are definitely taken (have active A records). Domains with no A record are NOT confirmed available - they move to Step 2.

```bash
dig +short "$NAME.$TLD" A 2>/dev/null
```

- Has A record = **definitely taken** (skip whois)
- No A record = **unknown** (MUST verify with whois)

**Step 2: Whois verification (MANDATORY for all DNS-clear results)**

Every name that passes the DNS pre-filter MUST be verified via whois before being reported as "available." This is non-negotiable - parked/reserved domains without DNS records are extremely common, especially for short names (4-6 chars).

```bash
# .com - check Verisign registry directly
whois -h whois.verisign-grs.com "$NAME.com"
# If "No match" = truly available. If "Domain Name:" appears = registered.

# .io
whois -h whois.nic.io "$NAME.io"

# .market
whois -h whois.nic.market "$NAME.market"

# .app
whois -h whois.nic.google "$NAME.app"

# .co
whois -h whois.nic.co "$NAME.co"
```

**Interpreting whois results:**
- Response contains `"Domain Name: NAME.TLD"` = **REGISTERED** (not available)
- Response contains `"No match"` or no domain entry = **AVAILABLE**
- Timeout or error = **UNKNOWN** (retry or flag as unverified)

Run whois checks in parallel batches of 10-15 to avoid rate limiting (whois servers are slower than DNS).

**Reporting:** Only mark a domain as "avail" if whois confirms it is not registered. Mark DNS-only results as "unverified" and flag them for the user.

Write results to `$WORK_DIR/domain-results.tsv` with format: `name\ttld\tstatus\tmethod` (method = "whois" or "dns-only").

---

## Phase 4: Trademark Pre-Screen

### 4.1 USPTO Search

For the top 30 candidates (those with best domain availability), check for US trademark conflicts:

```bash
# iTunes-style search for similar marks
# Use the Marker API if available, otherwise fall back to web search
curl -s "https://markerapi.com/api/v2/trademarks/trademark/TERM/username/USERNAME/password/PASSWORD"
```

If no Marker API credentials, use WebSearch:
```
WebSearch: "CANDIDATE NAME" site:tsdr.uspto.gov OR site:tmsearch.uspto.gov
```

### Deep Brand Collision Check (Exa)
```bash
mcporter call 'exa.web_search_exa(query: "CANDIDATE brand company startup app", numResults: 5)'
```

For each candidate, note:
- Exact match found? (dead or alive mark?)
- Similar marks in same Nice class (Class 9: software, Class 42: SaaS)?
- Risk level: clear / caution / conflict

Write results to `$WORK_DIR/trademark-results.md`.

---

## Phase 5: App Store & Social Check

### 5.1 Apple App Store

```bash
# Search iTunes for name collisions (free, no auth)
curl -s "https://itunes.apple.com/search?term=CANDIDATE&entity=software&limit=5"
```

Check if any results are an exact or very close name match.

### 5.2 Google Play

Use WebSearch as a fallback:
```
WebSearch: "CANDIDATE" site:play.google.com/store/apps
```

### 5.3 Social Handles

Check major platforms for handle availability. Use direct URL probing:

```bash
# GitHub
curl -s -o /dev/null -w "%{http_code}" "https://github.com/CANDIDATE"

# Twitter/X - use WebSearch (direct URL check unreliable)
# Instagram - use WebSearch
# Reddit
curl -s -o /dev/null -w "%{http_code}" "https://www.reddit.com/user/CANDIDATE"
```

### GitHub Search
```bash
gh search repos "CANDIDATE" --limit 5
```

### Twitter/X Search
```bash
WebSearch: "CANDIDATE" site:twitter.com OR site:x.com
```

### Reddit Search
```bash
curl -s "https://www.reddit.com/search.json?q=CANDIDATE&limit=5" -H "User-Agent: research-agent/1.0" | jq '.data.children[].data | {title, selftext: .selftext[:300], subreddit, score}'
```

### YouTube Search
```bash
yt-dlp --dump-json "ytsearch3:CANDIDATE" 2>/dev/null | jq '[.[] | {title, channel, view_count, webpage_url}]'
```

### Brand Sentiment

Search Reddit for existing associations with the name:
```bash
curl -s "https://www.reddit.com/search.json?q=CANDIDATE&sort=top&limit=5" -H "User-Agent: research-agent/1.0" | jq '.data.children[].data | {title, selftext: .selftext[:200], score}'
```
Look for: negative associations, controversial usage, strong existing brands using the name.

Or if FindME CLI is installed:
```bash
findme CANDIDATE
```

Write results to `$WORK_DIR/social-results.md`.

---

## Phase 6: Scoring & Report

### 6.1 Score Each Candidate

Score each name (top 50 with best domain availability) on these criteria:

| Criterion | Weight | Description |
|-----------|--------|-------------|
| Pronounceability | 20% | Can someone say it correctly on first read? |
| Memorability | 15% | Does it stick after hearing once? |
| Scope | 15% | Does the name encompass the full product vision? |
| Domain availability | 20% | How many target TLDs are available? Is .com available? |
| Trademark clearance | 10% | Any conflicts in relevant classes? |
| App store clearance | 5% | Any name collisions on iOS/Android? |
| Social handle availability | 5% | Are @name handles available on major platforms? |
| Story / meaning | 10% | Does "what does the name mean?" lead to a compelling answer? |

### 6.2 Generate Final Report

Write the report to the output path. Structure:

```markdown
# Brand Naming Research Report

**Concept**: {user's description}
**Date**: {YYYY-MM-DD}
**Candidates explored**: {count}
**Domains checked**: {count}

---

## Top 10 Recommendations

{Ranked table with scores, available TLDs, trademark status, pronunciation}

## Tier 2: Strong Alternatives (11-25)

{Same format}

## Full Results by Category

### Modern / Compound
{table}

### Philosophical / Classical
{table with pronunciation guides}

### Invented / Neo-Latin
{table with etymology}

### Single Word
{table}

## Domain Availability Matrix

{Name x TLD grid showing available/taken}

## Trademark Notes

{Any conflicts or cautions for top candidates}

## App Store Collisions

{Any near-matches found}

## Social Handle Availability

{Top 10 candidates across major platforms}

## Methodology

- Word exploration: Datamuse API, ConceptNet, Big Huge Thesaurus, LLM philosophical knowledge
- Domain checks: {Instant Domain Search MCP / DNS+whois fallback}
- Trademark: {USPTO search method used}
- App stores: iTunes Search API, Google Play web search
- Social: {method used}
- All checks performed {date}. Domain availability is ephemeral - verify before purchasing.
```

### 6.3 Present Results

Display the Top 10 to the user with a brief explanation of each name's strengths.

Use AskUserQuestion to ask:
1. Do any of these resonate?
2. Want to explore variations on any specific name?
3. Want to run `/brand-check` on a specific candidate for deeper verification?

---

## Notes

### API Rate Limits
- Datamuse: 100,000/day (no auth)
- ConceptNet: ~5-10 req/sec (no auth)
- Big Huge Thesaurus: 10,000/day (no auth for basic)
- iTunes Search: no published limit (be reasonable)
- Instant Domain Search MCP: no published limit

### Parallelization
- Phase 1 agents run in parallel (4 concurrent)
- Phase 3 domain checks run in parallel batches of 20
- Phase 4-5 can run in parallel with each other

commands/brand-check.md

---
description: Deep verification of a single brand name - domains, trademarks, app stores, social handles
allowed-tools: Agent
argument-hint: <name> [--tlds ai,io,com,life,work]
---

# /brand-check - Single Name Deep Verification

Use the Agent tool to execute this workflow on a cheaper model:

- **model**: sonnet
- **description**: brand name verification

Pass the agent all workflow instructions below. Include the received arguments: `$ARGUMENTS`

After the agent completes, relay its report to the user exactly as received.

---

Run comprehensive availability checks on a single brand name candidate across domains, trademarks, app stores, and social media platforms.

## Input

```
$ARGUMENTS
```

---

## Phase 0: Parse Input

Extract from `$ARGUMENTS`:
- **Name**: The brand name to check (required). Can include multiple names separated by commas.
- **`--tlds <list>`**: (Optional) Comma-separated TLDs to check. Default: `ai,io,com,life,work,app,co,dev,org,net`

If no name provided, use AskUserQuestion to ask.

---

## Phase 1: Gather Bash-Based Data

Run the gather script to check domains, social media, app store, and GitHub/Reddit in parallel:

```bash
bash ~/.claude/lib/brand-check-gather.sh "{name}" "{tlds}"
```

For multiple names, run the script once per name. If checking 2+ names, run the bash calls in parallel tool calls.

The script outputs structured `=== SECTION ===` blocks: DOMAINS, SOCIAL, APPSTORE, GH_REPOS, REDDIT.

Interpret HTTP codes from SOCIAL section:
- 404 = likely available
- 200 = taken
- 301/302 = taken (redirect)
- 429 = rate limited (report as "unknown")

---

## Phase 2: Web Search Checks (parallel tool calls)

Run the following WebSearch/WebFetch calls **in parallel tool calls** (batch them into a single response, do not run sequentially):

> **Concurrency — avoid the 429 throttle.** Batch at most ~4 parallel WebSearch/WebFetch calls per message; if a call returns HTTP 429, wait ~30s and re-issue only the failed queries. (These are tool calls, not agents, but the same burst discipline applies.) See `~/.claude/rules/concurrency-and-rate-limits.md`.

1. **USPTO trademark**: `WebSearch: "{name}" trademark USPTO`
2. **WIPO trademark**: `WebSearch: "{name}" site:branddb.wipo.int OR "{name}" WIPO trademark`
3. **Google Play**: `WebSearch: "{name}" site:play.google.com/store/apps`
4. **Twitter/X**: `WebSearch: "{name}" site:twitter.com OR site:x.com`
5. **Instagram**: `WebSearch: "instagram.com/{name}"`
6. **LinkedIn**: `WebSearch: "linkedin.com/company/{name}"`
7. **Existing business**: `WebSearch: "{name}" company OR startup OR app -site:github.com`

If Instant Domain Search MCP tools are available, also call `search_domains` and `generate_domain_variations` in the same parallel batch.

If `mcporter` / Exa is available, add: `bash: mcporter call 'exa.web_search_exa(query: "{name} company startup app product", numResults: 5)'`

---

## Phase 3: Domain Pricing Reference

For available domains from Phase 1, note approximate pricing:
- `.com`: ~$10/yr, `.io`: ~$30-50/yr, `.ai`: ~$70-90/yr, `.life`: ~$5-15/yr
- `.work`: ~$5-10/yr, `.app`: ~$15-20/yr, `.dev`: ~$12-15/yr, `.co`: ~$25-35/yr

---

## Phase 4: Analyze and Report

Synthesize all data into this report format:

```
--------------------------------------------
  BRAND CHECK: {NAME}
  {date}
--------------------------------------------

DOMAINS
  .ai      {available/taken}  {~$XX/yr}
  .com     {available/taken}  {~$XX/yr}
  .io      {available/taken}  {~$XX/yr}
  .life    {available/taken}  {~$XX/yr}
  .work    {available/taken}  {~$XX/yr}
  .app     {available/taken}  {~$XX/yr}
  .co      {available/taken}  {~$XX/yr}
  .dev     {available/taken}  {~$XX/yr}

TRADEMARKS
  USPTO:   {clear/caution/conflict} - {details}
  WIPO:    {clear/caution/conflict} - {details}

APP STORES
  Apple:   {clear/collision} - {details from gather + any WebSearch context}
  Google:  {clear/collision} - {details from WebSearch}

SOCIAL HANDLES
  GitHub:      {available/taken}
  Twitter/X:   {available/taken/unknown}
  Instagram:   {available/taken/unknown}
  Reddit:      {available/taken}
  YouTube:     {available/taken}
  TikTok:      {available/taken}
  LinkedIn:    {available/taken/unknown}
  ProductHunt: {available/taken}

EXISTING BUSINESSES
  {any notable entities using this name}

OVERALL ASSESSMENT
  {1-2 sentence summary: strong candidate / proceed with caution / significant conflicts}
```

### If Multiple Names

Run all checks for each name and present a comparison table at the end:

```
COMPARISON: {name1} vs {name2} vs {name3}

                    {name1}     {name2}     {name3}
Domains (of N TLDs) {X avail}   {X avail}   {X avail}
.com available?     {yes/no}    {yes/no}    {yes/no}
.ai available?      {yes/no}    {yes/no}    {yes/no}
Trademark clear?    {yes/no}    {yes/no}    {yes/no}
App Store clear?    {yes/no}    {yes/no}    {yes/no}
Social handles      {X/8}       {X/8}       {X/8}

Recommendation: {name}
```

lib (1)

lib/brand-check-gather.sh

#!/usr/bin/env bash
# brand-check-gather.sh - Parallel DNS/whois/curl checks for /brand-check
# Usage: brand-check-gather.sh <name> [tld1,tld2,...]
# Runs all bash-based checks concurrently. WebSearch calls remain in the agent.

NAME="$1"
if [ -z "$NAME" ]; then
  echo "ERROR: No name provided. Usage: brand-check-gather.sh <name> [tld1,tld2,...]"
  exit 1
fi

# Normalize to lowercase. printf '%s', not echo: bash's builtin echo
# flag-parses a leading -n/-e, so a name of exactly "-n" would silently
# become empty output here (bypassing the emptiness guard above, which
# runs before this normalization).
NAME=$(printf '%s' "$NAME" | tr '[:upper:]' '[:lower:]')

# TLDs from arg or defaults
if [ -n "$2" ]; then
  IFS=',' read -ra TLDS <<< "$2"
else
  TLDS=(ai io com life work app co dev org net)
fi

TMPDIR=$(mktemp -d)
trap "rm -rf $TMPDIR" EXIT
mkdir -p "$TMPDIR/dns" "$TMPDIR/whois" "$TMPDIR/social"

# --- Phase 1: Domain checks (parallel per TLD) ---

for tld in "${TLDS[@]}"; do
  (
    DOMAIN="${NAME}.${tld}"
    # DNS pre-check
    A=$(dig +short "$DOMAIN" A 2>/dev/null)
    NS=$(dig +short "$DOMAIN" NS 2>/dev/null)
    if [ -z "$A" ] && [ -z "$NS" ]; then
      DNS_STATUS="MAYBE_AVAIL"
    else
      DNS_STATUS="TAKEN"
    fi

    # Whois verification for MAYBE_AVAIL
    if [ "$DNS_STATUS" = "MAYBE_AVAIL" ]; then
      case "$tld" in
        com|net)
          whois -h whois.verisign-grs.com "$DOMAIN" 2>/dev/null | grep -q "No match" && WHOIS="AVAIL" || WHOIS="TAKEN" ;;
        io)
          whois -h whois.nic.io "$DOMAIN" 2>/dev/null | grep -qi "NOT FOUND" && WHOIS="AVAIL" || WHOIS="TAKEN" ;;
        ai)
          whois -h whois.nic.ai "$DOMAIN" 2>/dev/null | grep -qi "not registered" && WHOIS="AVAIL" || WHOIS="TAKEN" ;;
        work)
          whois -h whois.nic.work "$DOMAIN" 2>/dev/null | grep -qi "DOMAIN NOT FOUND" && WHOIS="AVAIL" || WHOIS="TAKEN" ;;
        app|dev)
          whois "$DOMAIN" 2>/dev/null | grep -qi "No match\|NOT FOUND\|No Data Found" && WHOIS="AVAIL" || WHOIS="TAKEN" ;;
        *)
          whois "$DOMAIN" 2>/dev/null | grep -qi "No match\|NOT FOUND\|No Data Found\|not registered\|DOMAIN NOT FOUND" && WHOIS="AVAIL" || WHOIS="TAKEN" ;;
      esac
    else
      WHOIS="TAKEN"
    fi

    echo "${tld}:${WHOIS}"
  ) > "$TMPDIR/dns/${tld}" 2>/dev/null &
done

# --- Phase 2: Social media curl probes (parallel) ---

# GitHub
(
  CODE=$(curl -s -o /dev/null -w "%{http_code}" "https://github.com/${NAME}" 2>/dev/null)
  echo "github:${CODE}"
) > "$TMPDIR/social/github" &

# Reddit subreddit
(
  CODE=$(curl -s -o /dev/null -w "%{http_code}" "https://www.reddit.com/r/${NAME}" 2>/dev/null)
  echo "reddit_sub:${CODE}"
) > "$TMPDIR/social/reddit_sub" &

# Reddit user
(
  CODE=$(curl -s -o /dev/null -w "%{http_code}" "https://www.reddit.com/user/${NAME}" 2>/dev/null)
  echo "reddit_user:${CODE}"
) > "$TMPDIR/social/reddit_user" &

# YouTube
(
  CODE=$(curl -s -o /dev/null -w "%{http_code}" "https://www.youtube.com/@${NAME}" 2>/dev/null)
  echo "youtube:${CODE}"
) > "$TMPDIR/social/youtube" &

# TikTok
(
  CODE=$(curl -s -o /dev/null -w "%{http_code}" "https://www.tiktok.com/@${NAME}" 2>/dev/null)
  echo "tiktok:${CODE}"
) > "$TMPDIR/social/tiktok" &

# Product Hunt
(
  CODE=$(curl -s -o /dev/null -w "%{http_code}" "https://www.producthunt.com/products/${NAME}" 2>/dev/null)
  echo "producthunt:${CODE}"
) > "$TMPDIR/social/producthunt" &

# --- Phase 3: App Store API (parallel) ---

(
  curl -s "https://itunes.apple.com/search?term=${NAME}&entity=software&limit=10" 2>/dev/null | \
    python3 -c "import sys,json; data=json.load(sys.stdin); [print(f'{r[\"trackName\"]} by {r[\"artistName\"]}') for r in data.get('results',[])]" 2>/dev/null || echo "unavailable"
) > "$TMPDIR/appstore" &

# --- Phase 4: GitHub repo search ---

(
  gh search repos "$NAME" --limit 5 2>/dev/null || echo "unavailable"
) > "$TMPDIR/gh_repos" &

# --- Phase 5: Reddit search ---

(
  curl -s "https://www.reddit.com/search.json?q=${NAME}&limit=5" -H "User-Agent: research-agent/1.0" 2>/dev/null | \
    python3 -c "import sys,json; data=json.load(sys.stdin); [print(f'{c[\"data\"][\"title\"]} (r/{c[\"data\"][\"subreddit\"]}, score:{c[\"data\"][\"score\"]})') for c in data.get('data',{}).get('children',[])]" 2>/dev/null || echo "unavailable"
) > "$TMPDIR/reddit_search" &

wait

# --- Output ---
echo "=== IDENTITY ==="
echo "name:${NAME}"
echo "tlds:${TLDS[*]}"
echo "date:$(date +%Y-%m-%d)"

echo ""
echo "=== DOMAINS ==="
for tld in "${TLDS[@]}"; do
  cat "$TMPDIR/dns/${tld}" 2>/dev/null || echo "${tld}:ERROR"
done

echo ""
echo "=== SOCIAL ==="
for f in "$TMPDIR/social"/*; do
  cat "$f" 2>/dev/null
done

echo ""
echo "=== APPSTORE ==="
cat "$TMPDIR/appstore"

echo ""
echo "=== GH_REPOS ==="
cat "$TMPDIR/gh_repos"

echo ""
echo "=== REDDIT ==="
cat "$TMPDIR/reddit_search"

View source on GitHub

Tags