How to add brand context to your AI product

TL;DR

Describe the whole generation job and resolve the customer's permitted brand on your server. Give each step the context it can use: writing guidance, visual references, or exact values and files. Keep those inputs on the same brand version, check the finished work, and refresh saved context when the brand changes.

Describe the whole job

When a customer asks your product for a launch email, the request can become several pieces of work: write the copy, generate a hero image, fill a template and check the result. Adding brand guidelines to the writing model covers only one of those steps. The template still needs its colours and font files, and the image model needs references for the imagery it will make.

Start by describing the complete output and which parts your product controls. Your application already knows details that a customer's short prompt may leave out: audience, dimensions, locked copy and the template's responsibilities. Those details help select the relevant brand guidance and assets.

Here is an illustrative task for an email builder. Acme and its product Atlas Pro are fictional:

A launch email for Acme's Atlas Pro, in a single-column 600 px template.
Outputs: a subject line, a preheader, three short body sections and a
1200 x 600 hero image with no text in it.
Audience: product designers on Acme's newsletter list.
Exact copy: headline "Meet Atlas Pro", button "Explore Atlas Pro".
Our template places the logo and sets all text.

The last line tells the image step what the renderer will handle. It also identifies where exact brand files will be needed. Keep this task with the job as it moves through your pipeline.

Connect the job to a maintained brand

Decide how much brand context the output needs. If you only fill a template with a logo, two colours and a font, a settings form and your database can be enough. Recurring work that depends on voice rules, imagery, a detailed brand guide and later corrections needs a way to maintain and select that context too.

A domain lookup can prefill what you know about a customer. Brandfetch's on-brand AI guide describes fetching a company profile on your server, adding it to the system prompt or retrieval context, and caching it by domain. Its Brand Context API describes identity, positioning, products, voice and visual style in prose; its docs direct readers to the Brand API for logo files, colour values and font names. A public lookup cannot supply a private guide or corrections the customer has shared only with your product.

The customer's own sources can include a website, brand guide, logo and font files, and existing work they want future outputs to follow. Turning those sources into reusable guidance, values and files is part of the integration, whether you build that yourself or call a service.

Rainbrand builds and maintains brand context that agents and products can use across jobs. Your server can add a brand from sources such as a website, an Instagram account and a brand guide PDF, with instructions about how to use them. Rainbrand builds the brand in the background and returns a Brand ID. Store that association against the customer in your system.

Adding brands, requesting Briefs and requesting Reviews use your Rainbrand account's credits (pricing).

Once the brand is ready, Get a brand returns its profile, including palette values, gradients, typography roles and logos. You can show the profile in your product so customers can identify missing or outdated details. Customers who already maintain their brand in Rainbrand can instead connect their account through OAuth.

Resolve customer access on your server

With a shared Rainbrand API key, your server can reach every customer's brand held in that Rainbrand account. Rainbrand checks whether the key can use the brand. Your application must establish which of your customers may use it.

For each request for guidance, review or a brand change, resolve the Brand ID on your server from the signed-in customer's authorized records. Do not accept an unchecked Brand ID from the browser or from a model's tool call. If an agent in your product requests context, expose a tool that takes the task; your server supplies the customer's Brand ID. A missing or unauthorized association should stop that request.

This affects the interface you choose. Rainbrand's integration guide offers Model Context Protocol (MCP) tools for agents and an API for workflows. Both reach the same brands. An MCP connection using your shared server key can list and use the account's brands, so for an agent serving multiple customers, wrap the needed API calls in your own tools and set the Brand ID in server code.

Managing your customers' brands covers the broader lifecycle and an authorization test. Here, the important result is that each generation job has a task and a brand it is allowed to use before context retrieval begins.

Retrieve and route the context

There are two kinds of input to retrieve. The brand profile supplies relatively stable values for the renderer: palette, gradients, typography roles and logo variants. Task guidance selects the rules and references that matter for this particular job.

A Rainbrand Brief provides that task guidance and the files selected for it. Send the authorized Brand ID and the complete task, wait for the Brief to finish, then pass its guidance and assets to the tools doing the work. The request reference asks for context that helps select the right guidance and files, which includes what your template already handles. For this workflow, a failed context request should return an error to your product instead of starting generation with missing brand inputs.

Request a Brief for the whole job, then route its parts to the steps that need them:

Keep the profile and Brief on the same brand version. The profile exposes the active version as activeSkill.id; a completed Brief records its saved version as skillId. Compare them before routing the work. If they differ, request a new Brief and restart with matching inputs. A null skillId means the saved version was deleted, so stop that attempt.

This illustrates the routing after your server has authorized the job. getBrand and themeFor are helpers your application implements, rather than Rainbrand SDK functions:

const { guidance, assets, skillId } = brief.data;
const currentBrand = await getBrand(brandId);

if (!skillId || currentBrand.activeSkill?.id !== skillId) {
  throw new Error("Request a new Brief with an available, matching version");
}

const copyStep = { task, guidance };

const imageStep = {
  task,
  guidance,
  references: assets.filter(
    (asset) => asset.kind === "image" || asset.kind === "font_render"
  ),
};

const renderStep = {
  theme: await themeFor(currentBrand, skillId),
  fonts: assets.filter((asset) => asset.kind === "font"),
  logos: assets.filter((asset) => asset.kind === "logo"),
};

// Cache the theme by version and save skillId with the output.

The brand profile's logo links are temporary; use each file's SHA-256 hash to store the file rather than treating its URL as permanent. Brief asset links have no scheduled expiry, but rely on the Brief, brand, saved version and asset remaining available. Anyone with one of those links can open the file, so treat it as a shareable link.

You can use the guidance and files with your own generation tools. For supported image and video models, Rainbrand's AI Gateway can add the Brief's guidance and visual assets when you pass its ID. Your product still supplies the task and controls how the output is made.

Put exact elements in the renderer

For the email task above, the template places the logo and text. Give it the original logo and font files. Ask the image model for the hero imagery, then let the renderer set the headline and button with exact brand values.

OpenAI's image generation guide documents limits in recurring brand consistency and precise composition. It also describes using images as references for new generations. Google's Gemini image models accept multiple reference images, with limits that vary by model. Supply visual references alongside written guidance; where text must be part of a generated image, check the result afterwards.

The distinction between naming a font and supplying its file is visible in an example for Eager, a juice brand. We asked Claude to develop a campaign for a blackcurrant-flavour concept. Claude requested one Brief for the campaign, including a landing page, campaign images, carousel, reel and film.

The Brief supplied guidance and font assets. The landing page then loaded a font file to typeset its text. Its saved stylesheet includes:

@font-face {
  font-family: "P22 Mackinac Pro";
  src: url("/examples/eager/fonts/p22-mackinac-pro-500.woff2") format("woff2");
  font-weight: 500;
  font-display: swap;
}

The renderer received something it could load and use. A font family name in the image prompt would not supply that file to the page.

If customers already have templates they want to use, fill those where possible. Canva's Autofill API supports this approach for brand templates kept in Canva. Your integration can preserve the template's layout while generating the content it needs.

Review the finished work

Check the assembled deliverable, including the parts your own template produced. Exact requirements belong in application checks: Atlas Pro is spelled correctly, required wording is present, the button points to the requested destination, and template colours come from the theme. These checks help isolate errors you can verify directly.

A Rainbrand Review checks work against the brand, with findings on areas such as colour, typography, logo and copy. For the email in this workflow, render it and submit a screenshot, along with the exact wording expected for the copy check. Each check returns a verdict, a short reason and evidence where available. Your pipeline uses those findings with its own tools to make corrections; Review does not edit the work automatically.

The saved Eager demonstration includes a landing-page correction that shows why the assembled output needs checking. Its final saved Reviews cover the submitted desktop landing-page capture, email capture and carousel slide 5. Each received passes for colour, typography, logo and copy. Those results describe the captures reviewed; they do not establish that the whole page, email or carousel passed.

Decide how your product handles findings before running an automatic revision loop:

The Review guide illustrates a limit of two editing rounds, which you can adjust for your task. Decide whether an unresolved job is returned with its findings or held for further attention. A failed operation should stop the loop. Save the Brief ID, brand version and Review ID with the output so you can trace what was used and what was checked.

Refresh context for the next job

Review findings and customer corrections can reveal a one-off production error or something to change in the saved brand. If a customer keeps replacing the same colour in drafts, offer to update the brand guidance so future jobs use that decision.

A Brand Edit prepares proposed changes. Applying the edit makes a new brand version active; preparing it alone does not change the brand. After it is applied, request a new Brief. A completed Brief remains tied to the version it was prepared from.

Refresh the copies used for new jobs: renderer themes, cached files and reusable task context. Keep the version records for completed outputs so their original inputs remain traceable. At the October 2026 source review, Rainbrand's API did not document change notifications. Read the brand profile when a job starts, then use the version check in the routing example to refresh mismatched inputs. Rainbrand does not rewrite copies stored in your system. Versioning brand guidelines covers this in more detail.

For your first deliverable, use the task description and routing table above to connect the entire job. Verify that it cannot request another customer's brand, that missing context stops the attempt, and that an applied brand change reaches the next job. The integration guide is the next step for wiring those calls into your product.