Converts websites, PDFs, and Figma libraries into a portable brand runtime that AI agents use to generate on-brand content and design tokens.
Also known as Brandcode-Studio/brandsystem-mcp, brandsystem-mcp, @brandsystem/mcp
- Stars
- 15
- Tools
- 12
- Downloads, 30 days
- 1,257
- Latest version
- 0.18.0
- Last commit
- Nov 13, 2026
- License
- MIT
What is Brandsystem MCP?
Brandsystem converts websites, PDFs, and Figma libraries into a portable brand runtime that AI agents use to generate on-brand content and design tokens. It exposes 12 tools, such as brand_start, brand_status, brand_compile.
Summary generated from the project's README
About Brandsystem MCP server
Brandsystem MCP allows developers to transform existing brand assets into a portable runtime that AI agents can use to maintain visual and verbal consistency. By providing a website, PDF, or Figma library, users can generate a structured .brand directory containing design tokens, voice rules, and compliance checks. This local-first approach requires no account and works via stdio with clients like Claude Desktop, Cursor, Windsurf, and Claude Code.
The server provides a suite of tools to automate the brand extraction process. It can compile DTCG tokens, generate CSS variables, or create Tailwind configurations to ensure code remains on-brand. For teams requiring a synchronized source of truth, the system can connect to Brandcode Studio to pull hosted brand data. This setup prevents the common issue of AI generating generic content by providing specific interaction policies and anti-patterns directly within the agent context.
What you can do with it
- 1Create social media contentInstruct an AI agent to produce marketing materials that adhere to established brand identities.
Written from the project's README. Every use case is checked against a quote from it.
How to install Brandsystem MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Brandsystem MCP in Claude Code
$ claude mcp add brandsystem-mcp -- npx -y @brandsystem/mcpInstall Brandsystem MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"brandsystem-mcp": {
"command": "npx",
"args": [
"-y",
"@brandsystem/mcp"
]
}
}
}Install Brandsystem MCP in VS Code
.vscode/mcp.json
{
"servers": {
"brandsystem-mcp": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@brandsystem/mcp"
]
}
}
}Install Brandsystem MCP in VS Code CLI
$ code --add-mcp '{"name":"brandsystem-mcp","type":"stdio","command":"npx","args":["-y","@brandsystem/mcp"]}'Install Brandsystem MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"brandsystem-mcp": {
"command": "npx",
"args": [
"-y",
"@brandsystem/mcp"
]
}
}
}Install Brandsystem MCP in Codex
$ codex mcp add brandsystem-mcp -- npx -y @brandsystem/mcpInstall Brandsystem MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.brandsystem-mcp] command = "npx" args = ["-y", "@brandsystem/mcp"]
Install Brandsystem MCP in Gemini CLI
$ gemini mcp add -s user brandsystem-mcp npx -- -y @brandsystem/mcpInstall Brandsystem MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"brandsystem-mcp": {
"command": "npx",
"args": [
"-y",
"@brandsystem/mcp"
]
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for @brandsystem/mcp 0.18.0 in an isolated container with no network and no keys. It answered and listed 12 tools.
Brandsystem MCP tools 12
Read from the server with tools/listbrand_startActionAdopt a brand into a portable .brand/ runtime from whatever source already exists: existing brand guidelines (PDF), a website URL, a Figma library, or a hosted Brandcode Studio brand. THE entry point when the user says 'use my existing brand guidelines with AI', 'I have a PDF brand guide', 'use our Figma library', 'create a brand system', 'extract brand from website', or 'set up brand guidelines'. Pass website_url, guideline_pdf, figma_file_key, or brandcode_url — or pass no source and it discovers local candidates and presents a menu with a privacy explanation. Set mode='auto' with a website_url to run the full pipeline (extract, compile DTCG tokens + design-synthesis.json + DESIGN.md + brand runtime + interaction policy, generate HTML report) in one call. If .brand/ already exists, returns current status with next steps. NOT for reading an already-compiled brand (use brand_runtime or brand_context) or for sharing an existing brand with a team (use brand_brandcode_connect).
brand_statusRead-onlyCheck brand system progress and get next steps. Shows what has been extracted (colors, fonts, logo), confidence levels, session completion status, and what to do next. Use when resuming a previous session, checking readiness, or when the user asks 'what's the state of my brand?' If no .brand/ exists, returns a full getting-started guide with all available tools. Returns structured status data.
brand_compileActionGenerate DTCG design tokens, design-synthesis.json, DESIGN.md, brand runtime, and interaction policy from extracted brand data. Transforms core-identity.yaml into tokens.json, brand-runtime.json (single-document brand contract for AI agents), and interaction-policy.json (enforceable rules). When Session 2+ data exists, also generates visual-identity-manifest.md and system-integration.md. Use after brand_extract_web, brand_extract_site, brand_extract_visual, or brand_extract_figma. Returns token counts, clarification items, and file list.
brand_clarifyActionResolve an ambiguous brand value interactively. After brand_compile, some values need human confirmation — wrong primary color, unknown font, unassigned color roles. Pass the clarification item ID and the user's answer (hex color, role name, font name, or 'yes'/'no'). Supports natural language: 'the purple one is accent' or '#5544f2 is secondary'. Returns updated identity and remaining clarification count.
brand_reportActionGenerate a portable HTML brand identity report with embedded logos, color swatches, typography, and tokens. The HTML is self-contained and works offline — upload it to any AI chat (Claude, ChatGPT, Gemini) as instant brand guidelines. Written to .brand/brand-report.html. Use after brand_compile. Returns file path, report summary (color/font/logo counts), and a ready-to-copy Brand Instructions text block.
brand_preflightActionCheck HTML/CSS against brand rules — catches off-brand colors, wrong fonts, missing logo, and anti-pattern violations (drop shadows, gradients, etc.). Pass an HTML string or file path. Mode 'check' (default) runs static source checks. Add render=true to render the page in sandboxed headless Chrome (all network blocked) and verify the COMPUTED result: actual colors vs palette (CIEDE2000), the font face that really renders, WCAG AA text contrast, logo presence, optional screenshot to .brand/checks/. Use after building any page or component, or when the user asks 'does this look on-brand?', 'check my page', or 'verify the design'. Mode 'rules' lists active rules. Returns overall PASS/WARN/FAIL, a score, and per-finding details (locator, measured value, nearest brand value, severity). NOT for scoring content copy — use brand_audit_content. NOT for brand directory validation — use brand_audit.
brand_runtimeRead-onlyRead the compiled brand runtime contract (brand-runtime.json). Returns the brand system that AI agents load as context for on-brand output. Supports slicing: 'full' (~1200 tokens, everything), 'visual' (~200 tokens, colors + fonts + anti-patterns), 'voice' (~400 tokens, tone + vocabulary + perspective), 'minimal' (~100 tokens, primary color + heading font). Use slices when passing brand context to sub-agents — smaller context reduces token cost and agent satisficing. Live Mode aware: when enabled via brand_brandcode_live, the runtime refreshes from the hosted Brandcode runtime on each call (subject to cache TTL). Falls back silently to the local mirror on network error. Read-only. Run brand_compile to refresh.
brand_contextRead-onlySelect a task-scoped brand context from the compiled runtime. THE tool to call first when the user says 'write this in our voice', 'write this LinkedIn post in our brand voice', 'make an on-brand social graphic', or 'build a landing page' — it returns only the governed rules relevant to that task instead of the full runtime. Deterministic: task_type maps to sections via a fixed table, audience matches governed personas exactly or reports no-match — no inference. Returns context (the selected brand slices), output_contract (required delivery shape), matched_selectors (what was chosen and why), and no_governed_match. NOT for reading the entire runtime (use brand_runtime) or checking finished content (use brand_check).
brand_checkRead-onlyInline brand linter — call this WHILE writing content or code, the way you call a type-checker. <50ms pass/fail on any combination of text (voice/never-say/AI-isms), color (palette match with ΔE distance), font (typography match), or css (anti-pattern violations). Designed for tight loops: write a sentence, brand_check it, fix, continue. Returns specific actionable fixes per failed input. Requires brand_compile to have run first. NOT a publish-time gate — use brand_check_compliance for the single PASS/FAIL verdict before shipping. NOT for 0-100 scoring — use brand_audit_content. NOT for HTML/CSS rule violations — use brand_preflight.
brand_brandcode_authActionActivate Brandcode Studio connection for saving and pushing brands. Preferred mode: "activate" displays a short code (e.g. BRAND-7K4X) for the user to enter at brandcode.studio/activate — no copy-paste of tokens needed. Also supports: "status" (check auth), "login" (magic link fallback), "set_key" (manual token), "logout" (clear credentials). Use when the user wants to save their brand to Studio or says "activate", "connect to Brandcode", or "save my brand online". NOT needed for extraction, preview, or brand_check — those work without auth.
brand_brandcode_connectActionConnect a local .brand/ to Brandcode Studio. Two modes: "pull" (default) downloads an existing hosted brand by URL/slug. "save" uploads the local .brand/ to Studio (requires prior auth via brand_brandcode_auth). THE tool when the user says "make our brand available to my whole team", "share our brand with the team", "connect to Brandcode", "pull from Studio", "save brand to Studio", or "upload my brand". Returns brand name, slug, sync token, and connection details.
brand_exportActionBundle the compiled brand system into a portable artifact in a destination's native format. Use when asked 'share my brand', 'export for ChatGPT/Cursor/Codex/team', 'add the brand to AGENTS.md', 'Cursor rules', 'CSS variables', 'Tailwind theme', 'shadcn theme', 'generate brand guidelines', or 'create a brand PDF'. Targets: 'chat' (markdown for any AI conversation), 'code' (MCP config + CLAUDE.md snippet), 'team' (human guidelines), 'email' (~500-word summary), 'claude-skill' (SKILL.md with embedded logo), 'pdf' (branded guide), 'agents-md' (AGENTS.md section), 'cursor-rules' (.cursor/rules/brand.mdc), 'css-variables' (:root --brand-* + dark block), 'tailwind' (v4 @theme CSS), 'shadcn' (shadcn/ui :root/.dark variables). CSS targets are generated from the compiled DTCG tokens. Writes to .brand/exports/<file> and returns the full content (text targets) or a generation summary (pdf). Requires brand_compile to have run first. NOT for previewing one section — use brand_preview.
Configuration
BRANDSYSTEM_PROJECT_DIR
Automated checks
Ran Nov 16, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablebrandcode-studio/brandsystem-mcp is public and reachablegithub.com/brandcode-studio/brandsystem-mcp ↗Pass
- Package names this repository as its source@brandsystem/mcp names brandcode-studio/brandsystem-mcp as sourcenpmjs.com/package/@brandsystem/mcp ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for @brandsystem/mcpnpmjs.com/package/@brandsystem/mcp/v/0.18.0#provenance ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-13github.com/brandcode-studio/brandsystem-mcp ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from @brandsystem/mcpPass
- No critical advisory in the package or its dependencies183 resolved dependencies checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model12 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubUse your brand guidelines with AI
@brandsystem/mcp turns the brand material you already have into context AI agents can use. Give it a website, PDF guide, Figma library, local files, or a Brandcode Studio brand. It produces a portable .brand/ runtime with design tokens, voice rules, provenance, and compliance checks.
Local-first. No account required. The default Core profile exposes 12 tools covering the complete adopt → use → check loop.
Start here
Install it for your agent, then ask: “How do I use my brand guidelines with AI?”
# Codex
npx @brandsystem/mcp install --client codex --write
# Claude Code, Cursor, Windsurf, or Claude Desktop
npx @brandsystem/mcp install --client claude-code --write
# Cline
npx @brandsystem/mcp install --client cline --write
Claude Desktop (one-click): download brandsystem-mcp-<version>.mcpb from the latest GitHub release and double-click it (or drag it into Settings > Extensions). Claude Desktop asks for the folder that holds your .brand/ directory — no Node install or JSON editing needed.
install is a dry run unless you pass --write. Replace claude-code with cline, cursor, windsurf, or claude-desktop as needed. JSON-file targets preserve existing settings; Cline and Codex setup delegate to their official MCP commands so their current schemas remain authoritative. Agents can follow the compact installation guide without reading this entire README.
Already configured? Tell your agent:
Use my existing brand guidelines with AI. Start from this website/PDF/Figma library and show me what needs human confirmation.
What It Solves
AI tools default to category-average output because they have no brand context. Brand guidelines live in PDFs, Figma files, and people's heads — none of which AI tools can read at the moment of creation. The dominant failure mode isn't "broken output"; it's "correct but generic" — output that passes mechanical checks but reads like a competent generalist could have made it.
This MCP server is the authoring half of the "Two MCPs, One Brand" model. It extracts brand identity from live sources, compiles it into a .brand/ directory with structured governance (anti-patterns, proof-point status, voice rules, application rules) plus DTCG tokens, brand-runtime.json, and interaction-policy.json. That directory is the portable brand runtime — the artifact that travels with your brand from surface to surface.
- Claude Design reads the
.brand/directory natively when pointed at a governed repo - Claude Code, Claude Desktop, Cursor, and Windsurf connect to this server directly over stdio and load
brand-runtime.jsonat generation time - ChatGPT and other remote-first clients consume the same runtime as an uploaded artifact (
brand-report.html/brand-runtime.json) or via a remote MCP connection — see Compatibility - @brandcode/mcp (the hosted Use MCP) serves the same runtime over HTTP for teams that want authenticated live reads at
mcp.brandcode.studio/{slug}
With brand-runtime.json loaded, agent prompts collapse from 200-400 tokens of inline brand context to just the delta. First output is on-brand. No review bottleneck.
Quick Start
1. Add to your MCP config
Copy this into .mcp.json (Claude Code), .cursor/mcp.json (Cursor), or Windsurf MCP settings. Codex users can run npx @brandsystem/mcp install --client codex --write instead:
{
"mcpServers": {
"brandsystem": {
"command": "npx",
"args": ["-y", "@brandsystem/mcp"]
}
}
}
For project-level configs committed to a repository, pin a version ("@brandsystem/mcp@<version>") so collaborators never auto-run an unreviewed release; npx @brandsystem/mcp install writes a pinned spec for you.
2. Create your brand system
Tell your AI tool:
Run brand_start with client_name="Acme Corp", website_url="https://acme.com", and mode="auto"
That single command extracts colors, fonts, and logo from the website, escalates to rendered or deeper multi-page extraction when the cheap pass is weak, compiles DTCG tokens, generates design-synthesis.json + DESIGN.md, and generates a portable HTML brand report -- all in under 60 seconds.
3. What you get
.brand/
brand.config.yaml ← brand name, source URLs, session state
core-identity.yaml ← colors (with roles), fonts, logo specs
tokens.json ← DTCG design tokens
brand-runtime.json ← single-file brand context for any AI agent
interaction-policy.json ← anti-patterns, voice constraints, never-say words
design-synthesis.json ← spacing, radius, shadows, component signals
DESIGN.md ← portable design brief (agent-readable)
brand-report.html ← visual report (paste into any AI chat)
assets/logo/ ← extracted logo files (SVG/PNG)
Load brand-runtime.json into any sub-agent's context. First output is on-brand. No per-prompt boilerplate.
4. Use it
Run brand_write for a social-graphic about "Q3 product launch"
The AI now has your full brand context — colors, typography, logo, anti-patterns, voice rules — and generates on-brand content.
Export to every tool's native format
Encode the brand once, then drop it into each tool in the format that tool already reads. brand_export writes to .brand/exports/:
| Target | Output | Where it goes |
|---|---|---|
agents-md |
AGENTS.md section (between brandsystem:start/end markers) |
Project-root AGENTS.md — read by Codex, Cursor, and other AGENTS.md-aware agents |
cursor-rules |
brand.mdc with description / globs / alwaysApply: false frontmatter |
.cursor/rules/brand.mdc — auto-attached to UI files |
css-variables |
:root { --brand-color-*; --brand-font-* } plus a [data-theme="dark"] / prefers-color-scheme: dark block when the brand has a dark palette |
Any stylesheet |
tailwind |
Tailwind CSS v4 @theme { --color-brand-*; --font-brand-*; --radius-brand-* } |
After @import "tailwindcss"; |
shadcn |
shadcn/ui :root + .dark variables (--background, --primary, --ring, --radius …) mapped from brand roles |
globals.css in a shadcn/ui project |
claude-skill, chat, code, team, email, pdf |
Skill file, chat upload, CLAUDE.md snippet, guidelines, summary, PDF guide | Claude skills, AI chats, teammates |
Run brand_export with target="tailwind"
CSS targets are generated from the compiled DTCG tokens; brand strings are validated (hex colors, plausible font names, quoted families) so nothing extracted can break out of a declaration. Instruction targets (agents-md, cursor-rules) carry the provenance notice and keep brand values in a fenced data block.
5. Go deeper (optional)
| Session | What it adds | Command |
|---|---|---|
| 1. Core Identity | Colors, fonts, logo, tokens | brand_start (done above) |
| 2. Visual Identity | Composition, anti-patterns, illustration style | brand_deepen_identity |
| 3. Messaging | Voice, tone, never-say words, brand story | brand_compile_messaging |
| 4. Content Strategy | Personas, journey stages, themes | brand_build_personas |
Each session enriches brand-runtime.json. Stop at any point — Session 1 alone is valuable.
6. Share with your team
Run brand_brandcode_connect to save on Brandcode Studio
Your brand persists on brandcode.studio. Teammates pull the same brand into their tools. One source of truth.
What It Does
Session 1: Core Identity -- Extract colors, fonts, and logo from a website or Figma file. Compile into DTCG tokens, a structured design synthesis layer, a portable DESIGN.md, and an HTML report.
Session 2: Visual Identity -- Define composition rules, pattern language, illustration style, and anti-patterns through a guided interview. Anti-patterns become enforceable compliance rules.
Session 3: Messaging -- Audit existing website voice, then define perspective, voice codex (tone, vocabulary, AI-ism detection), and brand story through a guided interview.
Session 4: Content Strategy -- Build buyer personas, journey stages, editorial themes, and a persona x stage messaging matrix.
Each session builds on the previous. Stop anywhere -- you get value immediately.
Two Ways To Use It
Local-first MCP flow -- Start from a website or Figma file, build a .brand/ directory locally, and use it immediately in chat or code tools with no account required.
Brandcode Studio-connected flow -- Connect an existing hosted brand from Brandcode Studio, pull the packaged brand into .brand/, and keep it synced over time.
Two MCPs, One Brand
The .brand runtime is the product. Two MCPs serve it:
@brandsystem/mcp — Build (this package). Author and compile the .brand runtime locally. Extract from websites, Figma, and PDFs. Compile governance (anti-patterns, proof-point status, voice rules, application rules) plus DTCG tokens, brand-runtime.json, and interaction-policy.json into a single .brand/ directory. Portable, versionable, ready to commit to any repo.
@brandcode/mcp — Use (hosted). Connect authorized MCP clients to the live Full Brand Runtime at https://mcp.brandcode.studio/{slug} with Brandcode bearer-key auth. Agents fetch the current runtime, search approved knowledge, check drafts, retrieve package-safe assets, leave append-only review feedback, and, with explicit capture scope, queue taste captures for human review — no per-tool guideline copy, no stale snapshots, no canonical mutation from the MCP. Tagline: "Your brand, live in every AI tool."
Same .brand runtime artifact. Two consumption paths. Build authors it; Use serves it.
Phase 0 for Brandcode MCP is locked in specs/brandcode-mcp-phase-0-lock.md as the original 8-tool read/append-only surface. The current hosted implementation adds capture_taste as a scoped contribute-tier tool: it requires explicit capture scope, queues a review candidate for human review, and never promotes canon.
Hosted availability: Brandcode MCP is pre-release and available to approved clients only — it is not yet publicly launched or registry-listed. Brand data on the hosted service is client-owned; feedback is append-only; agent history is scoped and redacted. Deletion and export requests are handled through your Brandcode Studio contact. Until public launch, use @brandsystem/mcp for local build/sync, and Live Mode (brand_brandcode_live) for connected reads that refresh from the hosted runtime within a short cache TTL.
Maintainers can verify a hosted deployment end-to-end with the smoke harness (npm run smoke:hosted-mcp with BRANDCODE_MCP_SMOKE_URL and scoped test keys). It verifies MCP initialize, tools/list, the locked hosted tool order, core hosted tool calls, and read-only insufficient-scope behavior. It never hardcodes keys; missing proof inputs are reported as blocked or skipped.
Claude Design integration
The .brand/ directory is engineered as a first-class input for Claude Design. Point Claude Design at a repo that contains .brand/ — governance YAML, narrative library, proof-point files, taste notes, DTCG tokens — and it grounds on the governed brand instead of improvising from uploaded assets. This is the Deploy path: author once with @brandsystem/mcp, then every Anthropic surface (Claude Design, Claude Code, Chat via compile packs) consumes the same runtime.
Tools Reference
Tool Profiles (0.10+)
By default the server registers the Core profile — 12 tools covering the complete loop: adopt → runtime/context → create → check → export, plus the Studio connector entry points and the clarify/promote path. This keeps first-tool selection sharp for agents.
Core also offers brand_feedback automatically after a failure. It stays out of the tool list until a tool in the session errors, has to elide an oversized response, or reports a LOW or empty extraction. Then the server lists it (via notifications/tools/list_changed) and the failing response's next_steps points to it, for clients that don't refresh their tool list. Nothing is sent automatically: a report goes to the Brandcode team only when an agent calls brand_feedback, and it contains the note the agent writes, never .brand/ files. See docs/DATA-FLOWS.md.
The full profile registers the entire authoring system (all tools below). Opt in via env or args:
{
"mcpServers": {
"brandsystem": {
"command": "npx",
"args": ["-y", "@brandsystem/mcp", "--profile=full"]
}
}
}
Or set BRANDSYSTEM_PROFILE=full. Core tools: brand_start, brand_status, brand_runtime, brand_context, brand_check, brand_preflight, brand_report, brand_export, brand_clarify, brand_compile, brand_brandcode_auth, brand_brandcode_connect.
Entry Points
| Tool | What it does |
|---|---|
brand_start |
Begin here. Creates a brand system from a website URL in under 60 seconds. Use mode='auto' for one-call setup with rendered and deep-site fallback on weak JS-rendered sites. |
brand_status |
Check progress, get next steps, or see a getting-started guide if no brand exists yet. |
Session 1: Core Identity
| Tool | What it does |
|---|---|
brand_extract_web |
Extract logo (SVG/PNG), colors, and fonts from any website URL. |
brand_extract_visual |
Screenshot the rendered page in headless Chrome and extract computed colors, fonts, and visual context from JS-heavy sites. |
brand_extract_site |
Discover representative pages, render them across desktop and mobile, capture screenshots, sample multiple components, and persist extraction-evidence.json. |
brand_generate_designmd |
Generate design-synthesis.json and DESIGN.md from extracted evidence or the current brand state. |
brand_extract_figma |
Extract from Figma design files (higher accuracy). Two-phase: plan then ingest. |
brand_set_logo |
Add/replace logo via SVG markup, URL, or data URI. |
brand_compile |
Generate DTCG design tokens, brand runtime contract, and interaction policy from extracted data. |
brand_clarify |
Resolve ambiguous brand values interactively (color roles, font confirmations). |
brand_audit |
Validate .brand/ directory for completeness and correctness. |
brand_report |
Generate portable HTML brand report. Upload to any AI chat as instant guidelines. |
brand_init |
Low-level directory scaffolding. Prefer brand_start instead. |
Session 2: Visual Identity
| Tool | What it does |
|---|---|
brand_deepen_identity |
Define composition rules, patterns, illustration style, and anti-patterns (6 interview sections). |
brand_ingest_assets |
Scan and catalog brand assets with MANIFEST.yaml metadata. |
brand_preflight |
Check HTML/CSS against brand rules -- catches off-brand colors, wrong fonts, anti-pattern violations. Add render: true to verify the computed result in sandboxed headless Chrome (see Checking what you built). |
Session 3: Messaging
| Tool | What it does |
|---|---|
brand_extract_messaging |
Audit existing website voice -- fingerprint, vocabulary, claims, AI-isms, gaps. |
brand_compile_messaging |
Define perspective, voice codex (tone, vocabulary, AI-ism detection), and brand story. |
Session 4: Content Strategy
| Tool | What it does |
|---|---|
brand_build_personas |
Build buyer personas through a 7-question guided interview. |
brand_build_journey |
Define buyer journey stages (ships with 4 proven defaults). |
brand_build_themes |
Define editorial content themes balanced across awareness, engagement, and conversion. |
brand_build_matrix |
Generate messaging variants for every persona x journey stage combination. |
Content Scoring
| Tool | What it does |
|---|---|
brand_audit_content |
Score content against brand rules (0-100) across multiple dimensions. |
brand_check_compliance |
Quick pass/fail compliance gate before publishing. |
brand_audit_drift |
Detect systematic brand drift across multiple pieces of content. |
Runtime + Utilities
| Tool | What it does |
|---|---|
brand_runtime |
Read the compiled brand runtime contract (single-document brand context for AI agents). |
brand_context |
Select a task-scoped slice of the runtime deterministically (task_type → sections, audience → persona match, compact budget). Returns matched selectors and explicit no-match — never silent fallback. |
brand_write |
Load full brand context (visual + voice + strategy) for content generation. |
brand_export |
Export the brand in each tool's native format: AGENTS.md, Cursor rules, CSS variables, Tailwind v4 theme, shadcn/ui theme, Claude skill, chat/team/email markdown, or PDF. |
brand_feedback |
Report bugs, friction, or feature ideas to the brandsystem team. |
Brandcode Studio Connector
| Tool | What it does |
|---|---|
brand_brandcode_connect |
Connect a local .brand/ directory to a hosted Brandcode Studio brand and pull the current package. |
brand_brandcode_sync |
Pull updates from a previously connected hosted brand using sync-token-aware delta behavior. |
brand_brandcode_status |
Inspect the current Brandcode Studio connection, sync history, and local package summary. |
brand_brandcode_live |
Toggle connected read tools to refresh from the hosted runtime within a short cache TTL. |
Tool Flow
Tools auto-chain -- each tool's response tells the LLM what to run next:
Session 1: brand_start → brand_extract_web or brand_extract_visual or brand_extract_site → brand_generate_designmd → brand_compile → brand_clarify → brand_report
Session 2: brand_deepen_identity (interview x 6) → brand_compile (generates VIM)
Session 3: brand_extract_messaging → brand_compile_messaging (interview x 3) → brand_write
Session 4: brand_build_personas → brand_build_journey → brand_build_themes → brand_build_matrix
brand_status can be called at any point. brand_preflight runs after any content generation.
Checking what you built
Static checks read the source. A page can declare the brand font and still render in a fallback, or use the right hex on a background that makes the text unreadable. brand_preflight with render: true checks the computed result in a real browser:
{ "html": "site/index.html", "render": true, "viewport": "mobile", "screenshot": true }
- Input: an HTML string, or a path to an
.htmlfile inside the working directory (symlink-aware containment). Stylesheets,@imports, scripts, fonts, and images that live inside the working directory are inlined before rendering. - Sandbox: the page renders in the same locked-down headless Chrome used for extraction (Chromium sandbox on, service workers bypassed), with all network egress denied. The egress proxy refuses every connection and the request interceptor aborts anything that is not
data:,blob:, orabout:. Remote fonts and CDN stylesheets do not load. The response lists what was blocked so you can switch to local copies. - What it measures: for every visible element, the computed text, background, and border colors (alpha-composited), the font face that actually renders (the first available family in the stack), font sizes and weights, and whether a logo renders.
- What it checks:
R-COLOR: CIEDE2000 distance to the nearest brand color. ≤2.3 matches, ≤6 is reported as info ("use the exact value"), above that is a warning, and above 15 is an error. Low-chroma neutrals are always allowed. Whileclarify-primaryis open, color errors are advisory.R-FONT: the rendered face must be a brand font. Generic and system fallbacks after the brand font are fine. A brand font that is declared first but cannot load is reported as info.R-CONTRAST: WCAG AA (4.5:1, or 3:1 for large text), measured on the real foreground and background. Text over images or gradients is counted as indeterminate.R-LOGO: the brand name renders as text but no logo SVG or image renders.
- Output:
overall(PASS/WARN/FAIL), a 0–100score(color 40 / typography 30 / contrast 30), and findings sorted by severity. Each finding has a locator, the measured value, the nearest brand value or required threshold, and an occurrence count, capped bymax_findings. The response also carries the measured palette and type scale, a compactstatic_preflightsummary, and, withscreenshot: true, a PNG path under.brand/checks/to show the user. Hard anti-pattern failures from the static rules also fail the rendered check.
Requires a local Chrome or Chromium install. Without one, the tool says so and points you back to the static check.
Brandsystem MCP questions
How do I add Brandsystem MCP to Claude Code?
Run claude mcp add brandsystem-mcp -- npx -y @brandsystem/mcp in your terminal. Add --scope user to make it available in every project.
How do I add Brandsystem MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does Brandsystem MCP provide?
It exposes 12 tools, including brand_start, brand_status, brand_compile, brand_clarify, brand_report.
How do I use my brand guidelines with AI?
You can install the server for your specific client (like Claude Code, Cursor, or Windsurf) and then use commands to extract brand identity from websites, PDFs, or Figma libraries.
Do I need an account to use this?
No, the local-first workflow allows you to build and use your brand runtime without an account.