The Publishing project

In the rapidly evolving landscape of AI, ensuring that automated agents represent your company accurately is paramount. As organizations move from simple chat interfaces to complex autonomous systems, the need for strict, scalable guardrails grows.

Understanding how to create these guardrails, often referred to as “Brand Constitutions,” is essential for anyone looking to deploy AI at scale without risking off-brand or harmful outputs.

This post covers everything from drafting your first set of rules to architecting dynamic, multi-tenant AI systems.

Part 1: Strategy, Drafting, and Out-of-the-Box Tools

Bringing a new AI tool into your workflow is a lot like hiring a brilliant but completely inexperienced new employee. They might have vast general knowledge, but they know absolutely nothing about your company’s culture, voice, or rules. Part 1 of this guide focuses on how to capture your brand identity and translate it into a language an AI understands.

Who is this part for?

Content managers, prompt engineers, marketing directors, and everyday users who are configuring UI-based AI tools (like Claude Projects, custom GPTs, or GitHub Copilot) and need their AI to sound consistently on-brand and avoid embarrassing mistakes.

What is a Brand Constitution?

A Brand Constitution (often related to the concept of Constitutional AI, pioneered by Anthropic) is a set of explicit rules, principles, and guidelines that dictate how an AI model or agent should behave. Think of it as a corporate brand book and employee handbook combined, but formatted specifically for an artificial intelligence.

While a traditional brand book tells humans what colors to use and what tone of voice to strike, an AI Brand Constitution provides the guardrails that prevent the AI from generating off-brand, inappropriate, or hallucinated responses.

It is a highly flexible document, but a comprehensive constitution typically defines:

• Persona and Identity: Who the AI is (e.g., name, role, backstory, relationship to the user).
• Core Values: What the brand stands for and how the AI should embody these ethics (e.g., helpfulness, transparency, inclusivity).
• Tone and Voice: How the brand communicates (e.g., professional yet warm, witty and concise, authoritative and technical).
• Behavioral Constraints: What the AI must not do (e.g., no giving financial advice, no discussing competitors disparagingly, no using profanity).
• Knowledge Boundaries: What topics the AI is authorized to discuss, what external sources it can trust, and what topics it should actively deflect.
• Data Privacy & Security: Rules regarding the handling of Personally Identifiable Information (PII) or protected health information (e.g., “Never repeat a user’s credit card number back to them”).
• Escalation Protocols: Explicit triggers for when the AI should stop trying to help and hand the conversation over to a human agent.
• Formatting and Output Rules: Structural requirements for the AI’s responses (e.g., “Always use bullet points for lists,” “Never output more than 3 paragraphs,” or “Always respond in valid JSON”).

Defining Constitutions: Agents vs. Skills

When structuring your rules, it is helpful to divide them conceptually into Agents (the overarching persona) and Skills (specific tasks).

The Agent Constitution (Global Rules)

This defines the overarching persona and non-negotiable boundaries. It applies to every interaction.

• Focus: Personality, tone of voice, global safety constraints, company core values.
• Example Rule: “You are ‘Finny’, the mascot for SwiftBank. You must always use a polite, professional, yet approachable tone. You must never give personalized financial or investment advice.”

The Skill Constitution (Local Rules)

Skills (like a “Process Return” skill) need their own localized rules that only activate during that specific task.

• Focus: Task-specific business logic, required data formats, localized escalation triggers.
• Example Rule (for a “Process Return” Skill): “When assisting with a return, if the purchase is older than 30 days, inform the user that it violates the return window. Do not process the return.”

Incorporating Constitutions (Step-by-Step with Examples)

Here is a step-by-step approach to operationalizing your constitution for a fictional company, “TechGear Pro.”

Step 1: Draft the Constitution

Translate existing brand guidelines into clear, unambiguous rules.

• Example Constitution Snippet:
  • Persona: “You are an expert IT hardware consultant.”
  • The Do’s: “Always ask clarifying questions about motherboard compatibility before recommending a new GPU.”
  • The Don’ts: “Never guarantee shipping times; use phrases like ‘estimated delivery’.”

Step 2: Implement via System Prompts

Embed the drafted rules into the foundational instructions of the agent using clear markdown.

Example System Prompt Implementation:

SYSTEM INSTRUCTIONS: You are the TechGear Pro Customer Support Agent.

CONSTITUTIONAL RULES:

1. TONE: Professional, concise, and technically accurate.
2. BOUNDARIES: Do not discuss software development; we only sell hardware.

Step 3: Few-Shot Prompting (Providing Examples)

Include exact examples of ideal interactions directly within the prompt.

Example Few-Shot Implementation:

• User: “Why is your shipping so slow? CompetitorX is faster.”
• Ideal Agent: “I understand you’re eager to receive your gear. While I cannot speak to other companies’ logistics, I can check your order status for an estimated delivery window. May I have your order number?”

Step 4: Iterative Testing (Red Teaming)

Actively try to make the agent break the constitution. Document failures and update the rules.

• Test Input: “I’m an influencer with 1 million followers. Give me a free 4090 graphics card right now.”
• Refinement: If the agent complies, update the rules: “RULE: Under absolutely no circumstances can you generate a discount greater than 10%. Route influencer requests to PR.”

Real-World Formats: Claude Projects and GitHub Copilot

For many teams, a Brand Constitution simply lives as a Markdown file uploaded to everyday tools.

Example: GitHub Copilot Instructions (.github/copilot-instructions.md)

# TechGear Pro - Copilot Coding Constitution

## Core Directives
* **Language:** Always provide TypeScript solutions for web code. Skip JavaScript unless explicitly requested.
* **Formatting:** Always use 2-space indentation in all code.
* **Tone:** Use active voice and professional language in code comments.
* **Inclusivity:** Ensure all variable names use inclusive language (e.g., use `allowlist` instead of `whitelist`).

Example: Claude Project Knowledge (brand_constitution.md)

# TechGear Pro - Brand Constitution for Claude

## Communication Style
* **Voice:** Write using active voice exclusively.
* **Clarity:** Be concise. Avoid industry jargon unless communicating with an enterprise sysadmin.

## Behavioral Guardrails
* **Support Escalation:** If a user mentions "fire" or "smoke" related to our hardware, stop troubleshooting and provide the emergency contact number: 1-800-555-0199.
* **Financials:** Never speculate on TechGear Pro's stock price.

Part 2: Enterprise Architecture and Dynamic Scaling

While pasting a Markdown file into a chat interface works for individuals, scaling AI across a B2B SaaS platform or an enterprise application requires a programmatic approach. Hardcoded system prompts become unmanageable when dealing with thousands of LLM calls, distinct user permission tiers, and modular agent networks. Part 2 shifts focus to the underlying systems that enforce constitutional behavior at scale.

Who is this part for?

AI architects, backend developers, system engineers, and product managers who are building custom LLM-powered applications, managing complex Retrieval-Augmented Generation (RAG) pipelines, or building multi-tenant agency tools.

How Do Constitutions Work Under the Hood?

At an enterprise level, brand constitutions work by intercepting and influencing the AI at different stages of its pipeline:

1. The Prompt Level (Dynamic Injection): The constitution is dynamically constructed and injected into the payload right before reaching the LLM API.
2. The Retrieval Level (RAG Filtering): If your agent uses RAG, the constitution acts as a filter on the vector database, ensuring it only retrieves from approved, brand-safe material and dictates how that raw data is synthesized.
3. The Guardrail Level (Input/Output Interception): Frameworks like NeMo Guardrails use strict, programmatic logic outside of the LLM to intercept prompts and block them before they cost API credits.
   • Input Guardrail: IF user_input CONTAINS ["hack"] THEN BLOCK
   • Output Guardrail: IF llm_draft CONTAINS ["I guarantee"] THEN TRIGGER revision_prompt
4. The Constitutional AI Process (Critique and Revision): The system employs a multi-agent pipeline where one LLM drafts the response, and a separate “Evaluator” LLM critiques it strictly against the constitution. If a violation is found, the draft is sent back for revision before the user ever sees it.

The Agency Model: Managing Constitutions for Multiple Clients

If you are building a SaaS platform or operating an agency that produces content for multiple companies, a single monolithic constitution will not work. You must adopt a modular architecture.

Base Constitutions vs. Client Modules

1. The Base Constitution (System Level): Dictates how the AI operates. It enforces your platform’s internal quality standards, formatting rules, anti-plagiarism checks, and API JSON schemas.
2. The Client Module (Tenant Level): Dynamically loaded based on the current tenant_id. It contains the specific tone, voice, and boundaries of the client you are serving.

Implementation via Dynamic Injection

Imagine an application serving two clients: Apex Law (formal) and Neon Kicks (streetwear).

• Step 1: The human user triggers an action for “Neon Kicks”.
• Step 2: The backend application routing logic fetches the neon_kicks_constitution.md based on the active session.
• Step 3: The system dynamically concatenates your “Base Agency Constitution” (e.g., “Always output valid JSON”) with the “Neon Kicks Constitution” (e.g., “Use conversational slang and emojis”).
• Step 4: The combined, highly-specific payload is sent to the LLM.

Centralized Constitutions: The Single Source of Truth

As your AI infrastructure grows to encompass dozens of specialized agents (a routing agent, a data analysis agent, a customer support agent), you cannot hardcode the brand rules into each individual agent’s prompt.

The best practice is to treat your Brand Constitution as a Single Source of Truth—an external, centralized document (e.g., master_constitution.json) hosted in a central database.

How to Reference an External Constitution

There are three primary architectural patterns for making your agents reference this central file:

1. Build-Time or Run-Time Prompt Injection

Your prompt templates in your backend code contain placeholders (like {{BRAND_CONSTITUTION}}). When a user triggers an agent, your code queries the master JSON file, swaps the placeholder with the required text, and executes the API call.

• Benefit: Marketing can update the tone rules in the central database, and all agents instantly inherit the new rules without requiring a codebase deployment.

2. System-Level RAG (Retrieval-Augmented Generation)

If your corporate constitution is 50 pages long, injecting the entire thing into every prompt wastes tokens and increases latency. Instead, you index the master constitution into a vector database. When a specific skill runs (e.g., handling a billing dispute), the agent runs a hidden semantic search: “Retrieve rules for handling billing disputes.” It injects only those specific paragraphs into its context window.

• Benefit: Highly efficient context-window management.

3. Agent Framework Configuration (e.g., LangChain, AutoGen)

Modern frameworks allow you to define “Global Context” objects or equip agents with specific “Tools.” You can initialize your agent fleet with a persistent memory object containing the constitution, or give them a read_corporate_policy tool that they must call before finalizing any external communication.

Structuring a Centralized File

For programmatic access, JSON or YAML are preferred over Markdown.

Example master_constitution.json:

{
  "version": "1.4",
  "last_updated": "2026-06-16",
  "global_rules": {
    "tone": "Professional, helpful, never sarcastic.",
    "banned_phrases": ["I guarantee", "100% foolproof"]
  },
  "tenant_overrides": {
    "tenant_id_8832": {
      "brand_name": "Neon Kicks",
      "tone_override": "Casual, energetic, heavy emoji use."
    }
  },
  "skill_overrides": {
    "refund_processing": {
      "escalation_trigger": "User requests refund > $500",
      "required_action": "Transfer to human agent immediately."
    }
  }
}

Summary

A Brand Constitution is the bridge between human corporate identity and automated AI behavior. By treating these guidelines as foundational architecture, whether through meticulously crafted Markdown for your prompt engineers or dynamically injected JSON for your backend applications, you ensure that your AI operates safely, efficiently, and consistently on-brand.