Reviewing Multi-Reference Image Briefs in Sanity Studio

The situation

Any team producing posters, product visuals, or campaign layouts eventually runs into the same bottleneck: image briefs arrive with multiple reference files, vague sourcing notes, and no clear record of who approved what. By the time a brief reaches a designer or an AI image tool, nobody can say whether the references are rights-cleared, whether alt text was considered, or whether the brief actually matches the brand guidelines it cites.

Sanity Studio is a reasonable place to solve this, not because it generates images, but because it's built for structured review before content moves downstream. A well-modeled "image brief" document gives editors a single place to check references, rights, and accessibility notes before anyone opens an editing tool.

A compact schema example

Here's a minimal but realistic starting point for an imageBrief document type:

export default {
name: 'imageBrief',
title: 'Image Brief',
type: 'document',
fields: [
{ name: 'title', type: 'string', validation: Rule => Rule.required() },
{ name: 'brand', type: 'reference', to: [{ type: 'brandGuideline' }] },
{
name: 'references',
title: 'Reference Images',
type: 'array',
of: [{
type: 'image',
fields: [
{ name: 'source', type: 'string', title: 'Source or owner' },
{ name: 'usageRights', type: 'string', title: 'Rights status',
options: { list: ['owned', 'licensed', 'unverified'] } },
{ name: 'alt', type: 'string', title: 'Alt text' }
]
}],
validation: Rule => Rule.min(1).max(6)
},
{ name: 'prompt', title: 'Creative direction / prompt notes', type: 'text' },
{
name: 'status',
type: 'string',
options: { list: ['draft', 'in review', 'approved', 'sent to production'] },
initialValue: 'draft'
},
{ name: 'reviewer', type: 'reference', to: [{ type: 'person' }] }
]
}

The key design choice is nesting rights and alt-text fields directly inside each reference image, rather than storing them as freeform notes elsewhere. That way, an editor can't approve a brief without at least seeing that a rights field is empty.

Validation rules that actually catch problems

A few validation patterns worth adding on top of the base schema:

• Require usageRights to be set to something other than "unverified" before status can move to approved. This needs a custom validation function or a document-level action, since cross-field checks aren't expressible in a single field rule.
• Cap the reference array (as above) so briefs stay reviewable; six images is a reasonable ceiling for a human to actually compare.
• Make alt required whenever the brief's status is anything past draft. Accessibility notes get skipped when they're optional, so tying the requirement to workflow stage keeps it from becoming an afterthought.

An editorial workflow, not just a schema

The schema only matters if it's paired with a workflow. A workable pattern:

1. Draft — a requester adds references and prompt notes. Rights fields can stay unverified at this stage.
2. In review — an editor checks each reference for source and rights, adds missing alt text, and leaves comments (Sanity's Studio supports inline notes on documents for this).
3. Approved — status only changes once every reference has a rights status and alt text. This is where the custom validation earns its keep.
4. Sent to production — the brief is considered finished input for whatever downstream design or image tool the team uses next.

This four-stage split keeps the review burden visible instead of buried in a Slack thread, and it gives you a queryable record later if a rights question comes up.

A reusable review checklist

For teams that want something simpler than enforcing every rule in code, a checklist embedded in the Studio's document description (or a linked guideline document) covers most of the same ground:

• Does every reference list a source and rights status?
• Is at least one reference tagged "owned" or "licensed," not just "unverified"?
• Does every image have alt text that describes content, not just filename?
• Does the prompt or direction text reference the correct brand guideline document?
• Has a named reviewer been assigned before status changes to "approved"?

Where a downstream tool like Muse Image fits

Once a brief is approved in Sanity, someone still has to turn references and direction into a finished image. This is a separate step, done in a separate tool—there's no integration between Sanity and any particular image generator, and building one isn't something this workflow assumes.

For that downstream step, a browser-based option like Muse Image is worth knowing about if your team needs to combine multiple reference images and iterate on a prompt before finalizing a poster, product shot, or layout. It's described as a text-to-image and editing workspace that supports multi-reference composition, which maps reasonably well onto a brief that already has several approved references attached. The two tools don't talk to each other automatically; someone exports or re-uploads the approved references and prompt text manually.

Limitations worth naming

This model doesn't solve everything. Cross-field validation in Sanity requires custom code, not just schema options, so teams without developer support may need to enforce some checks manually through the checklist instead. Rights verification is only as good as what a reviewer actually checks—the schema records a status, it doesn't confirm licensing. And no content model can guarantee a downstream tool interprets a prompt the way the brief intended; that's still a human judgment call at handoff.

What structured review does provide is a clear, queryable record of what was approved, by whom, and under what rights—something worth having regardless of which image tool comes next.

Sanity – The Content Operating System that ends your CMS nightmares

Sanity replaces rigid content systems with a developer-first operating system. Define schemas in TypeScript, customize the editor with React, and deliver content anywhere with GROQ. Your team ships in minutes while you focus on building features, not maintaining infrastructure.

Sanity scales from weekend projects to enterprise needs and is used by companies like Puma, AT&T, Burger King, Tata, and Figma.