BGML - Brand Governance Markup Language

BGML v0.1 - Portable Knowledge Packs for AI Brand Governance

BGML is a portable packaging specification for brand governance data. Using BGML, organisations can bundle Brando-structured policies, guidelines, approved assets, controls, examples, and references into machine-readable knowledge packs that can move across systems.

Where Brando Schema defines the vocabulary for governed brand knowledge, BGML defines how that knowledge is packaged, validated, distributed, and retrieved at runtime by AI systems, agents, and content workflows.

See the Brando Schema overview for the underlying vocabulary that BGML packages.

BGML: portable knowledge packs for AI brand governance

What BGML Is

BGML is a package specification, not a platform, not a CMS, not a model, and not a proprietary runtime.

BGML defines how to assemble governed brand knowledge into a portable bundle that can be stored, versioned, transported, and served to downstream systems.

A BGML package can include:

Brand core: identity, mission, positioning, values, naming, and strategic guidance
Verbal governance: tone of voice, approved messaging, terminology, claims rules, and writing controls
Visual governance: colour tokens, typography guidance, logo usage, imagery policies, layout guidance, and design references
Assets: approved logos, templates, icons, fonts, imagery, and linked source files
Controls: required, discouraged, prohibited, reviewable, and escalated rules
Examples: approved and rejected examples that help humans and AI systems apply brand rules correctly
References: supporting evidence, source documents, legal notes, disclosures, and audit materials
Runtime metadata: retrieval hints, applicability, priority rules, review dates, and validation information

BGML makes brand governance portable across retrieval layers such as RAG pipelines, MCP servers, APIs, CMS workflows, and internal repositories.

How BGML Relates to Brando Schema

BGML does not replace Brando Schema.

The two layers do different jobs:

Brando Schema: the open vocabulary for structured brand identity, governance, and content guidance
BGML: the portable package format for Brando-structured brand knowledge

Brando defines the meaning of the data. BGML defines how the data is bundled for use across systems.

A simple way to think about the architecture is:

Brando = schema
BGML = package
IBOM = implementation methodology

Using Brando Schema, brands can codify guidelines, policies, assets, and controls as machine-readable entities, then distribute them as portable BGML knowledge packs.

Why BGML Exists

Brand guidelines are often trapped in PDFs, slide decks, design files, shared folders, and disconnected documents. These formats may work for human reference, but they are difficult for AI systems to retrieve, validate, and apply consistently.

BGML exists to make governed brand knowledge:

Portable: able to move across tools, teams, and infrastructures
Machine-readable: structured for LLMs, agents, APIs, and retrieval systems
Composable: organised into reusable modules rather than one monolithic document
Auditable: linked to sources, controls, review dates, and evidence
Versionable: stored in Git or other repositories with clear package history
Implementation-agnostic: usable with any infrastructure stack

The goal is not just to store a brand book digitally. The goal is to package brand governance in a way that systems can retrieve and apply operationally.

What a BGML Pack Contains

A BGML pack is a structured bundle of files.

A typical package may include:

a package manifest
brand-level metadata
Markdown documents for authored policies and guidance
YAML frontmatter for structured metadata
JSON-LD sidecars for machine-readable entity representations
approved asset files and registries
examples and evidence records
runtime retrieval and validation metadata

Example package layout:

acme-brand.bgml/
  manifest.yaml
  brand/
    brand.yaml
    positioning.md
    mission.md
  policies/
    tone-of-voice.md
    tone-of-voice.json
    claims-policy.md
    claims-policy.json
    disclosures-policy.md
    disclosures-policy.json
  design-system/
    colour-tokens.yaml
    typography-tokens.yaml
    logo-usage.md
    imagery-policy.md
  assets/
    logos/
    templates/
    fonts/
  examples/
    approved/
    rejected/
  references/
    source-register.yaml
    evidence-register.yaml
  runtime/
    retrieval-index.json
    chunk-map.json

This structure is illustrative, not mandatory in every implementation. BGML defines the package conventions and required metadata so tools can interpret a pack consistently.

The BGML Document Pattern

BGML works especially well with the Brando document triad pattern:

Markdown body: the authored document content for humans
YAML frontmatter: the structured metadata attached to that document
JSON sidecar: the machine-readable representation of the same governed entity

These three parts describe one governed object, not three unrelated files.

In BGML, multiple governed objects can be assembled into a single portable package with shared manifests, asset registries, references, and runtime metadata.

How It Works

1. Codify the brand with Brando Schema

Teams model brand identity, policies, assets, rules, and references using Brando entity types and properties.

2. Assemble a BGML package

Those governed entities are grouped into a portable package with a manifest, file structure, and supporting assets.

3. Validate the package

The package can be checked for missing files, broken references, invalid metadata, unresolved assets, expired reviews, or incomplete controls.

4. Serve the package to systems

Organisations can expose BGML packs through:

RAG pipelines
MCP servers
APIs
CMS and publishing workflows
internal repositories and knowledge services

5. Retrieve and apply at runtime

LLMs, agents, search systems, and content workflows can retrieve relevant policies, assets, and controls from the package and apply them consistently.

What BGML Is Not

Not a replacement for Brando Schema
Not a vector database
Not a model fine-tuning format
Not a CMS
Not a proprietary platform
Not limited to one cloud, one vendor, or one retrieval stack

BGML is a packaging standard for governed brand knowledge.

Implementation Patterns

Organisations can implement BGML in different ways depending on their infrastructure and governance maturity.

Common patterns include:

Git-based repositories storing BGML packs as versioned files
static publishing workflows exposing package files through a CDN
MCP servers serving BGML pack contents to tools and agents
RAG systems indexing BGML package content for retrieval
custom APIs returning selected entities and assets from a pack
CMS workflows publishing selected BGML content into channels and templates

Infrastructure choices may include:

self-hosted environments on DigitalOcean, AWS, Azure, or on-prem
managed RAG or search platforms
hybrid architectures combining Git, object storage, APIs, and retrieval layers

BGML is infrastructure-agnostic.

Design Principles

A BGML implementation should aim for the following qualities:

Open: based on portable files and open schemas
Modular: policies, assets, and rules can be updated independently
Determinable: systems can identify what applies, what is prohibited, and what requires review
Traceable: claims, examples, and controls link back to evidence or source material
Versioned: package changes are visible and reviewable over time
Deployable: the package is ready for operational use by AI systems and content workflows

Example Manifest

A BGML package typically starts with a manifest file describing the package and its entry points.

bgmlVersion: "0.1"
packageId: "com.acme.brand.core"
packageType: "brand-governance-pack"
brandId: "https://example.com/brands/acme"
brandName: "Acme"
brandoVersion: "1.3"
defaultLocale: "en-GB"
markets:
  - UK
  - IE
channels:
  - web
  - email
  - social
effectiveDate: "2026-04-23"
reviewDate: "2026-10-23"
modules:
  - core
  - verbal
  - visual
  - policy
  - assets
entrypoints:
  brand: "brand/brand.yaml"
  policies:
    - "policies/tone-of-voice.json"
    - "policies/claims-policy.json"
authorityOrder:
  - legal
  - regulatory
  - corporate-brand
  - campaign
  - channel

This is an example only, but it shows the kind of package metadata BGML is designed to standardise.

The Role of IBOM

Intelligent Brand Operating Model (IBOM) is Advanced Analytica's proprietary consulting methodology for implementing governed brand systems.

IBOM can be used to help organisations:

assess current brand governance maturity
codify guidelines into structured formats
design architecture for retrieval and operational use
deploy Brando and BGML into live workflows
establish governance and assurance processes

IBOM does not equal BGML.

Brando Schema is the open vocabulary
BGML is the portable packaging specification
IBOM is the consulting methodology used to implement them

Contributing

BGML is intended to evolve through open specification work, implementation testing, and community feedback.

Areas for contribution may include:

package manifest conventions
validation profiles
asset registry patterns
retrieval and chunking guidance
interoperability with design systems and CMS workflows
mappings between Brando entities and BGML modules

Licence & Trade Marks

The Brando Schema vocabulary is published under:

Creative Commons Attribution 4.0 International (CC BY 4.0)
W3C Royalty-Free Patent Policy

Trade marks:

Brando, IBOM, and QWIKI are trade marks of Advanced Analytica Limited
schema and specification licences do not grant trade mark rights

See Terms for complete details.