Agent Memory for Content Generation

1. Brand voice rules (keyword)
   → Agent knows tone, vocabulary, values to apply

2. Similar prior outputs (semantic)
   → Agent sees examples of voice-in-action, avoids repetition, matches style

3. Campaign history & performance (temporal + semantic)
   → Agent knows what messaging worked, what didn't, seasonal patterns

4. Audience preferences (keyword)
   → Agent tailors depth, length, format to segment expectations

import { Brain } from "brain-ai";

const memory = new Brain({
  namespace: "content-generation",
});

// When generating content:
async function generateContent(brandId: string, contentType: string, audience: string, topic: string) {
  // 1. Get brand voice rules
  const voiceRules = await memory.retrieve({
    agentId: `brand-${brandId}`,
    query: "brand voice tone vocabulary values do's don'ts guidelines",
    topK: 10,
    filters: { type: "brand_voice_rule" },
  });

  // 2. Get similar prior outputs
  const priorOutputs = await memory.retrieve({
    agentId: `brand-${brandId}`,
    query: topic, // Semantic: find content on similar topics
    topK: 8,
    filters: { type: "prior_output", metadata: { contentType } },
  });

  // 3. Get campaign history
  const campaignHistory = await memory.retrieve({
    agentId: `brand-${brandId}`,
    query: `${topic} performance messaging ${audience}`,
    topK: 5,
    filters: { type: "campaign_history" },
  });

  // 4. Get audience preferences
  const audiencePrefs = await memory.retrieve({
    agentId: `brand-${brandId}`,
    query: `${audience} preferences engagement style depth`,
    topK: 5,
    filters: { type: "audience_preference", metadata: { segment: audience } },
  });

  // Build content context
  const contentContext = {
    voiceRules,
    styleExamples: priorOutputs,
    campaignPerformance: campaignHistory,
    audienceExpectations: audiencePrefs,
    contentType,
    topic,
    audience,
  };

  // Agent generates content on-brand and on-target
  const content = await contentGenerator.generate(contentContext);

  // Store generated content in memory
  await memory.store({
    agentId: `brand-${brandId}`,
    content: `${contentType}: "${content.headline}"\n\n${content.body}`,
    type: "prior_output",
    metadata: {
      brandId,
      timestamp: new Date().toISOString(),
      contentType,
      topic,
      audience,
      headline: content.headline,
      wordCount: content.body.split(" ").length,
      voiceScore: analyzeVoiceConsistency(content, voiceRules),
    },
  });

  return content;
}

// When campaign concludes, log performance:
async function logCampaignPerformance(brandId: string, campaignName: string, metrics: any) {
  await memory.store({
    agentId: `brand-${brandId}`,
    content: `Campaign "${campaignName}" completed: ${metrics.summary}`,
    type: "campaign_history",
    metadata: {
      brandId,
      timestamp: new Date().toISOString(),
      campaignName,
      focusTheme: metrics.theme,
      openRate: metrics.openRate,
      clickRate: metrics.clickRate,
      conversionRate: metrics.conversionRate,
      keyMessages: metrics.keyMessages,
      audienceSegment: metrics.targetAudience,
    },
  });
}

// When audience provides feedback:
async function logAudienceFeedback(brandId: string, segment: string, feedback: string) {
  await memory.store({
    agentId: `brand-${brandId}`,
    content: `${segment} feedback: ${feedback}`,
    type: "audience_preference",
    metadata: {
      brandId,
      timestamp: new Date().toISOString(),
      segment,
      feedbackCategory: categorizeFeedback(feedback),
      sentiment: analyzeSentiment(feedback),
    },
  });
}

Brand: SaaS productivity platform

Q1 Campaign Theme: "Productivity" — Email sequence about time-saving

AI Memory Lookup:
1. Brand voice rules:
   - Tone: "Warm + expert, never salesy"
   - Values: "Helping teams collaborate better"
   - Do: "Use short sentences. Speak to emotional payoff. Give concrete examples."
   - Don't: "Jargon without explanation. Hype language. Generic B2B clichés."

2. Prior outputs: None yet (first campaign)

3. Campaign history: None yet (first campaign)

4. Audience preferences:
   - Tech buyers (CTOs, PMs): "Want technical proof points, architecture insights"
   - SMB owners: "Want quick wins, time-save quantified"

AI generates Q1 email:
"Subject: Your team's 6 hours back every week
Hi [Name],

We helped a 12-person marketing team reclaim 6 hours every week.
Not from automating. From organizing.

No more: Looking for the last meeting's notes (5 min × 10 people = 50 min/week). Duplicating work because someone missed context (3 people × 2 hours = 6 hours/week).

They tracked their own time. With [product], they found those pockets instantly.

Want to do the same?
[CTA]"

Q1 Result: 22% open rate, 4% click rate. Performance logged.

---

Q2 Campaign Theme: "Security" — Email sequence about data safety

AI Memory Lookup:
1. Brand voice rules: (same as above)

2. Prior outputs:
   - Q1 email: "Warm tone, specific example (12-person team), quantified payoff (6 hours)"
   - Pattern: Success = Concrete example + Emotion + Quantified benefit

3. Campaign history:
   - Q1: 22% open, 4% click. Key message: "Reclaim time"
   - TechBuyers responded well to "architecture" angle
   - SMB owners responded well to "quick wins" framing

4. Audience preferences:
   - TechBuyers: Want "what if breach?" + "how protected?" (technical reassurance)
   - SMB owners: Want "compliance simple?" + "peace of mind" (emotional reassurance)

AI generates Q2 email (TechBuyer variant):
"Subject: What if your memory was breached?
Hi [Name],

When a SaaS platform stores memory (customer data, conversation history, decisions), breach risk is real.

Here's what we do:
- End-to-end encryption: Your memories encrypted at rest, in transit
- Compliance: SOC 2 Type II, GDPR ready, HIPAA available
- Audit trails: We log who accessed what, when

Not 'trust us'. Verifiable.

If you're storing memory, you need to know where it lives.

[CTA for security brief]"

Q2 Result (TechBuyer segment): 28% open, 6% click. Performance logged. SMB segment: 18% open, 2% click (different messaging needed).

---

Q3 Campaign Theme: "Teams" — Email sequence about collaboration

AI Memory Lookup:
1. Brand voice rules: (same as above + new note: "For Q3, emphasize collaboration emotion")

2. Prior outputs:
   - Q1: Concrete example + emotion + quantified benefit = 22% open
   - Q2 Tech: Technical reassurance = 28% open
   - Q2 SMB: Security email felt too technical = 18% open (mismatch)

3. Campaign history:
   - Q1: "Productivity" messaging outperformed with SMB
   - Q2: TechBuyer + technical = strong. SMB + security = weak
   - Insight: Segment response differently

4. Audience preferences:
   - TechBuyers: Technical depth + verification = engage
   - SMB owners: Emotional resonance + simplicity = engage
   - Update: "SMB wants less jargon than previously thought"

AI generates Q3 email (SMB variant):
"Subject: Your team asked for this feature
Hi [Name],

What does every 10-person team ask for?
'Can I see what we told you?' / 'Did we mention this before?' / 'Who made that decision?'

Your team's memory. Searchable. Trustworthy.

In Q3, we made it effortless:
- Search your past conversations in 2 seconds
- See who said what, when
- No complexity

Your team collaborates better when it remembers.

[CTA]"

Projected Q3 result (SMB): 24% open (closer to Q1 emotional tone), 4-5% click (matching SMB segment preference for simplicity).

interface ContentGenerationMemory {
  agentId: string; // "brand-{brandId}"
  namespace: "content-generation";

  // What was stored
  content: string; // The voice rule, content sample, campaign summary, or feedback

  // How to retrieve it
  type: "brand_voice_rule" | "prior_output" | "campaign_history" | "audience_preference";
  metadata: {
    brandId: string;

    // For brand_voice_rule
    ruleCategory?: string; // "tone", "vocabulary", "values", "do", "don't"
    rule?: string; // The actual guideline
    priority?: "critical" | "important" | "nice-to-have";

    // For prior_output
    contentType?: string; // "email", "blog", "social", "ad", "landing_page"
    topic?: string;
    headline?: string;
    wordCount?: number;
    audience?: string;
    voiceScore?: number; // How consistent with brand rules (0-100)
    publishedDate?: string; // ISO 8601

    // For campaign_history
    campaignName?: string;
    focusTheme?: string; // "productivity", "security", "teams"
    targetAudience?: string;
    openRate?: number;
    clickRate?: number;
    conversionRate?: number;
    keyMessages?: string[]; // Main talking points
    duration?: string; // "2026-01-01 to 2026-03-31"

    // For audience_preference
    segment?: string; // "TechBuyers", "SMB", "Enterprise"
    preferenceType?: string; // "depth", "length", "tone", "format"
    preference?: string; // "want technical deep-dives", "prefer quick tips"
    evidenceStrength?: "strong" | "moderate" | "weak"; // Based on engagement data

    timestamp: string; // ISO 8601
  };
}