GENYS · Use Cases

Brand Memory

Lock in your brand’s voice, claims, and constraints so every output learns and compounds—across channels, teams, and time. GENYS stores durable facts and tone vectors, retrieves only what matters, and guards every generation.

Request Access Try the Playground

In production today powering DesignAdvertise.ai—campaigns that learn, adapt, and scale.

Simple

Your voice, every time — Writers and agents stay on‑brand automatically—no giant prompt docs.
Facts don’t drift — Claims, approvals, and disclaimers are remembered and cited.
Design stays consistent — Logos, palettes, and style tokens guide creatives and UIs.
Learns across launches — What worked last quarter informs the next brief by default.

Technical

Capsules store tone vectors, brand claims, legal constraints, and visual tokens with provenance, scope, and retention.
RAG++ planner retrieves top‑k brand truths and prior decisions; compacts a minimal context bundle.
ToneGuard checks outputs against the Brand Vector Hash and capsule facts; blocks or edits on drift.
Telemetry tracks drift, token burn, latency, and business KPIs to auto‑tune retrieval weights.

What goes into Brand Memory

Voice & Style

Tone vectors (e.g., bold‑power), lexicon, banned phrases, reading level, example comps.

Claims & Proof

Allowed claims, substantiation, citations, competitor do/don’t rules.

Visual Tokens

Palette, typography, spacings, component tokens; asset manifests with rights.

Approvals

Who approved what and when; jurisdictional notes; redaction/retention policy.

Audience Memory

Segments, ICP snapshots, objection maps, offer libraries, prior A/B results.

Guardrails

Restricted topics, crisis scripts, compliance checklists per channel.

In production: DesignAdvertise.ai

DesignAdvertise.ai runs on the GENYS memory layer to ship campaigns that improve over time. Brand Capsules drive tone, claims, and channel choices; Telemetry feeds back CTR/CPL/demos so the next brief starts smarter.

Brand‑safe generation

Every asset is checked by ToneGuard and capsule facts before approval.

Cross‑channel continuity

Email, ads, landing pages reference the same Brand Vector Hash.

Learning briefs

New campaigns inherit successful messages and retire underperformers.

See a live demo Talk to us

Implementation in 5 steps

Collect brand truths (voice, claims, visuals) → normalize into Capsules with scope (tenant/app/user).
Map guardrails (ToneGuard vectors, banned phrases, restricted topics). Configure retention and legal holds.
Wire retrieval into your generator (RAG++ plan → compact context bundle with cites).
Approve & ship with audit (Capsule Chronicle logs writes, reads, policy checks, and exports).
Close the loop with Telemetry (drift, token burn, CTR/CPL/demos) to tune weights and update capsules.

// Create a Brand Capsule
await genys.capsules.create({
  subject: 'brand:acme',
  data: {
    tone: 'bold-power',
    lexicon: ['cut the fluff', 'ship fast'],
    claims: [{ text: 'Faster onboarding', proof: 'time-to-first-value study', jurisdiction: 'US' }],
    visuals: { palette: 'indigo-500/900', typography: 'Inter', spacingScale: '1.25' }
  },
  scope: { tenantId: 't_42', app: 'designadvertise' },
  retention: { ttlDays: 365 }
});

// Generate brand-safe copy
const result = await genys.generate({
  subject: 'brand:acme',
  input: 'Landing page hero for legal SMBs',
  retrieve: { k: 8, from: ['capsules','docs','events'] },
  guards: ['toneguard:brand_voice_prime','facts:capsule_consistency'],
  cite: true
});

Measuring success

Drift ↓

Track brand drift score and blocked outputs. Aim for stable or improving drift over time.

Token burn ↓

Compact context bundles vs. long prompts; monitor cost per shipped asset.

Conversion ↑

Observe CTR/CPL/demo rate per segment as memory accumulates learnings.

FAQ

Can Brand Memory handle multiple products or sub‑brands?

Yes. Use subject namespaces (e.g., brand:acme, brand:acme:product:x) and scope (tenant/app/user). Retrieval plans respect scope boundaries.

How do designers fit in?

Design tokens and component rules live in capsules; designers approve changes that propagate to generation and UI kits via tokens.

Is this model‑specific?

No. GENYS is model‑agnostic. Swap models; the brand truths, audit trail, and guardrails remain.

Get started Learn about Capsules

Brand tokens: sync Tailwind from Capsules

Fetch visual tokens from a Brand Capsule and expose them as CSS variables that Tailwind consumes. This keeps your site and your generation outputs aligned with the same source of truth.

// lib/brand-tokens.ts
export type BrandTokens = {
  colors: { primary: string; primaryDark: string; background: string; foreground: string };
  radius: { md: string; xl: string };
  typography: { fontFamily: string };
}

// Pull visuals from a Brand Capsule (subject = brand:acme)
export async function fetchBrandTokens(genys: any, brandId: string): Promise<BrandTokens> {
  const cap = await genys.capsules.get({ subject: 'brand:' + brandId, keys: ['visuals'] });
  const v = cap?.data?.visuals ?? {};
  return {
    colors: {
      primary: v.palette?.primary ?? '#6366f1',
      primaryDark: v.palette?.primaryDark ?? '#4f46e5',
      background: v.palette?.background ?? '#0b0f1a',
      foreground: v.palette?.foreground ?? '#ffffff',
    },
    radius: { md: v.radiusMd ?? '0.75rem', xl: v.radiusXl ?? '1rem' },
    typography: { fontFamily: v.typography ?? 'Inter, ui-sans-serif, system-ui' },
  };
}

export function toCssVars(tokens: BrandTokens) {
  return ':root{'
    + '--brand-primary:' + tokens.colors.primary + ';'
    + '--brand-primary-dark:' + tokens.colors.primaryDark + ';'
    + '--brand-bg:' + tokens.colors.background + ';'
    + '--brand-fg:' + tokens.colors.foreground + ';'
    + '--brand-radius-md:' + tokens.radius.md + ';'
    + '--brand-radius-xl:' + tokens.radius.xl + ';'
    + '--brand-font:' + tokens.typography.fontFamily + ';'
    + '}';
}

// tailwind.config.ts
import type { Config } from 'tailwindcss';

export default {
  content: ['app/**/*.{ts,tsx}', 'components/**/*.{ts,tsx}'],
  theme: {
    extend: {
      colors: {
        brand: {
          primary: 'var(--brand-primary)',
          primaryDark: 'var(--brand-primary-dark)',
          bg: 'var(--brand-bg)',
          fg: 'var(--brand-fg)',
        },
      },
      borderRadius: {
        md: 'var(--brand-radius-md)',
        xl: 'var(--brand-radius-xl)',
      },
      fontFamily: {
        brand: 'var(--brand-font)',
      },
    },
  },
} satisfies Config;

// app/layout.tsx (excerpt)
import { fetchBrandTokens, toCssVars } from '@/lib/brand-tokens';

export default async function RootLayout({ children }: { children: React.ReactNode }) {
  // In production, resolve tenant/brand from request
  const brandId = 'acme';
  const tokens = await fetchBrandTokens((global as any).genys, brandId);
  const css = toCssVars(tokens);

  return (
    <html lang="en">
      <body className="bg-brand-bg text-brand-fg font-brand">
        <style dangerouslySetInnerHTML={{ __html: css }} />
        {children}
      </body>
    </html>
  );
}

Usage

Tailwind classes now map to capsule tokens: bg-brand-bg, text-brand-fg, border-brand-primary, rounded-xl (using brand radius), and font-brand.

When DesignAdvertise.ai updates the Brand Capsule (e.g., palette refresh), rebuild or refresh and the UI picks up the new tokens automatically.

Brand tokens preview

Colors

Primary#6366f1

Primary (Dark)#4f46e5

Background#0b0f1a

Foreground#ffffff

Typography

Heading — Speed meets clarity

Body — Your brand font renders here so you can spot issues before you ship.

Radius

md (0.75rem)

xl (1rem)