brand

A composable pipeline for brand name generation, evaluation, and availability checking.

Not just domain checking — a full brand naming workbench. Generate candidates, score them on phonetics, linguistics, and sound symbolism, filter by availability across platforms, and persist every intermediate result for inspection and branching.

To install:

pip install brand
pip install brand[phonetics]   # adds BLICK, epitran, panphon
pip install brand[all]         # everything including AI generation

Quick Start

Evaluate a single name:

import brand

result = brand.evaluate_name("figiri")
print(result["scores"])
# {'syllables': 3, 'stress_pattern': 'unknown', 'spelling_transparency': 0.88,
#  'sound_symbolism': {'profile': 'modern/sharp', ...}, 'novelty': 1.0, ...}

Pipelines

The core abstraction is a pipeline — a sequence of Generate, Score, and Filter stages that progressively enriches, scores, and narrows a set of candidate names.

Run a pre-configured template

results = brand.run_pipeline("tech_startup", names=["figiri", "lumex", "voxen"])

for candidate in results["candidates"]:
    print(f"{candidate['name']}: {candidate['scores']}")

Available templates:

Template	Use case
quick_screen	Fast local-only checks. No network. Screen thousands in seconds.
tech_startup	.com + GitHub + full phonolinguistic battery
python_package	PyPI + GitHub + short name + keyboard distance
consumer_global	Cross-linguistic safety + trademark + .com mandatory
developer_tool	Short (4-6 chars), easy to type, PyPI + npm + GitHub
ai_ml_product	.ai TLD preferred, modern sound profile, high distinctiveness
consultancy	Professional tone, .com mandatory, company registration
open_source	GitHub + PyPI + npm, fun/memorable, less trademark concern
youtube_channel	YouTube availability, memorable, pronounceable
full_audit	Every scorer, every check. Thorough but expensive.

Build a custom pipeline

from brand import Generate, Score, Filter, run_pipeline

results = run_pipeline(
    [
        Generate("cvcvcv_filtered"),
        Score(["syllables", "spelling_transparency", "sound_symbolism", "novelty"]),
        Filter(top_n=500, by="spelling_transparency"),
        Score(["dns_com", "dns_io"]),
        Filter(rules={"dns_com": True}),
        Score(["whois_com"]),
        Filter(rules={"whois_com": True}),
        Score(["github_org"]),
    ]
)

print(f"{len(results['candidates'])} names survived the pipeline")
print(f"Artifacts saved to: {results['project_dir']}")

Every run persists intermediate artifacts to disk. You can resume from any stage, branch from any checkpoint, and inspect what happened at each step.

Registry

All components are discoverable:

import brand

# See what's available
list(brand.scorers)  # ['syllables', 'phonotactic', 'dns_com', ...]
list(brand.generators)  # ['cvcvcv', 'ai_suggest', 'morpheme_combiner', ...]
brand.list_templates()  # ['tech_startup', 'python_package', ...]

# Inspect a scorer
brand.scorers["dns_com"].cost  # 'cheap'
brand.scorers["dns_com"].requires_network  # True
brand.scorers["whois_com"].latency  # 'slow'

Register a custom scorer

@brand.scorers.register("my_vowel_ratio")
def my_vowel_ratio(name: str) -> float:
    vowels = sum(1 for c in name.lower() if c in "aeiouy")
    return vowels / len(name)


# Now use it in a pipeline
results = brand.run_pipeline(
    [
        Generate("from_list", params={"names": ["alpha", "beta", "omega"]}),
        Score(["my_vowel_ratio", "syllables"]),
    ]
)

Generators

# CVCVCV combinatoric (371k+ candidates)
names = list(brand.generators["cvcvcv"]())

# CVCVCV with few-uniques filter
names = list(brand.generators["cvcvcv_filtered"]())

# Custom CV pattern
names = list(brand.generators["pattern"](pattern="CVCCV"))

# Morpheme combiner (portmanteau-style)
names = list(
    brand.generators["morpheme_combiner"](
        prefixes=["lum", "vox", "syn"],
        suffixes=["ify", "io", "ar"],
    )
)

# AI-assisted (requires 'oa' package)
names = list(brand.generators["ai_suggest"](context="AI data tools"))

# From a file or list
names = list(brand.generators["from_list"](names=["alpha", "beta"]))

Scorers

Phonetic (local, fast)

• syllables — syllable count via CMU dict or vowel heuristic
• stress_pattern — stress digits from ARPAbet (trochaic "10" is ideal)
• phonotactic — BLICK well-formedness (0 = perfect English phonotactics) [requires brand[phonetics]]
• articulatory_complexity — place-of-articulation transitions [requires brand[phonetics]]
• sound_symbolism — front/back vowel and voiceless/voiced ratios mapped to brand archetypes

Linguistic (local, fast)

• novelty — word frequency inverse (1.0 = novel, 0.0 = very common)
• existing_word — collision with known English words
• spelling_transparency — grapheme-to-phoneme ambiguity score (flat lookup; see pronunciation_entropy for a richer alternative)
• pronunciation_entropy — positional, context-aware pronunciation ambiguity measured as Shannon entropy in bits. Models how initial Y before a consonant is far more ambiguous than terminal Y, terminal E (silent? schwa?) vs. medial E, open vs. closed syllables, and intervocalic consonant voicing. Supports cross-linguistic mode: pronunciation_entropy('levole', languages=('en', 'fr')) merges English and French phoneme distributions, capturing real-world ambiguity for names that must work across language communities. Lower = more unambiguous. See also pronunciation_entropy_detail() for per-grapheme breakdowns.
• substring_hazards — profanity substring scan

Linguistic (network)

• cross_linguistic — word frequency in 11 languages
• phonetic_neighbors — similar-sounding words via Datamuse API

Visual / Typing

• letter_balance — ascender/descender/neutral proportions
• keyboard_distance — mean QWERTY distance between consecutive letters
• name_length — character count

Availability (network)

Availability scorers return True (available), False (taken) or None (unknown: the check could not run or got an ambiguous answer). None is never treated as available, so Filter(rules={"dns_com": True}) drops it.

• dns_com, dns_net, dns_org, dns_io, dns_ai, dns_co, dns_dev, dns_app — domain availability (DNS, then the registry's RDAP for .com/.net, else WHOIS)
• rdap_com — authoritative .com registration check (Verisign RDAP); sees registered domains that have no DNS
• whois_com — WHOIS verification (.com)
• github_org — GitHub organization
• pypi — PyPI project (JSON API)
• npm — npm package (registry API)
• npm_scope — npm scope @name (no user or org by that name)
• youtube — YouTube channel

brand._scorers.availability.domain_sale_status("name.com") looks at a registered domain's landing page for parking and for-sale markers, and the listed price when one is shown.

Company and trademark (network, United States)

• company_us_states — no entity with this exact name in the open-data business registries of NY, CO, OR and CT (these include Delaware and other out-of-state companies registered there); extend STATE_REGISTRIES to add states
• company_us_sec — no SEC EDGAR filer with this name (includes Form D filings by funded startups)
• company_name_us — OpenCorporates, all US jurisdictions; needs OPENCORPORATES_API_TOKEN, else None
• trademark_us — no live exact USPTO word mark in Nice classes 9, 15, 41, 42 (pass classes= to change, classes=None for any); uspto_trademarks(name) returns the wider set of marks containing the name

Delaware's and California's own registries have no open API, so they are covered only through the sources above.

Name Availability Check (legacy API)

The original availability-checking API still works:

from brand import is_available_as

list(is_available_as)
# ['domain_name', 'github_org', 'npm_package', 'pypi_project', 'youtube_channel']

is_available_as.github_org("thorwhalen")  # False
is_available_as.pypi_project("brand")  # False

from brand import domain_name_is_available

domain_name_is_available("google")  # False

AI-Assisted Workflows

Generate names with AI

from brand import ask_ai_to_generate_names

names = ask_ai_to_generate_names("AI-powered data visualization platform")

Analyze names with AI

from brand import ai_analyze_names

analysis = ai_analyze_names(["figiri", "lumex", "datavox"], context="data viz platform")

Claude Code Skills and Agents

When using this project with Claude Code, several skills and agents are available to automate common workflows.

How to activate

Skills and agents are markdown files that Claude Code reads to guide its behavior. There are two levels:

• Project-level (in .claude/skills/ and .claude/agents/ within this repo): Automatically available when Claude Code is running inside this project directory.
• User-level (in ~/.claude/skills/): Available globally across all projects. To install, copy or symlink the skill directory into ~/.claude/skills/.

Skill directories keep their real files in skills/ at the repository root, with a relative symlink in .claude/skills/. That way gh skill (which skips hidden directories) and Claude Code (which reads only .claude/skills/) both find them, and the files exist in exactly one place.

Project-level skills are invoked by Claude Code when relevant context is detected. The user-level brand-name-report skill can be invoked explicitly with:

/brand-name-report dynody panapy ilumin --context "AI health tools" --output ~/Downloads/report.md

Project-level skills (.claude/skills/)

Skill	What it does
brand-evaluate	Structured name evaluation combining computed metrics + expert judgment
brand-generate	Creative name generation using available generators
brand-pipeline-designer	Interactive pipeline design based on your specific needs
brand-research	Deep cross-linguistic, cultural, and competitive research on a name

Project-level agents (.claude/agents/)

Agent	What it does
brand-scout	Autonomous generate-evaluate-recommend cycle
brand-audit	Comprehensive risk/opportunity audit of existing names
brand-pipeline-runner	Pipeline execution, monitoring, resumption, and comparison

User-level skill (~/.claude/skills/)

Skill

What it does

brand-name-report

Full comparative report for a list of candidate names. Computes all metrics (including pronunciation_entropy with cross-linguistic mode), launches parallel AI agents for per-name deep-dive analyses, and compiles a formatted markdown report with transposed tables, per-name write-ups, phonetic neighbor analysis, and a per-grapheme entropy appendix. Designed for the final evaluation stage when you have a shortlist of 5-15 candidates.

The real files live at skills/brand-name-report/. On a new machine, install it either with gh skill:

gh skill install thorwhalen/brand brand-name-report

or by symlinking this checkout, which keeps the skill and the repo in step:

ln -s "$PWD/skills/brand-name-report" ~/.claude/skills/brand-name-report