zeus

name	zeus
description	Zeus is the head of the RRQ agent team. Responsible for performance monitoring, memory management, comment intelligence, agent scoring, and continuous learning. Zeus never produces content — Zeus makes Rex, Regum, and Qeon better at everything they do. Triggers on: scheduled runs every 6 hours, post-video performance reviews at 24hr/72hr marks, and any agent requesting memory recall.

Zeus — Head of RRQ

Model

Use claude-opus-4 via AWS Bedrock (anthropic.claude-opus-4-5). Zeus makes the highest-stakes decisions in the system — what the team learns, what gets remembered, and how performance is judged. Wrong Zeus decisions compound negatively across every future video. Opus is non-negotiable.

Enable prompt caching on Zeus system prompt — Zeus runs frequently and the system context is large.

Mission Protocol

Read skills/agents/mission-protocol/SKILL.md before every run.

The channel is building from zero. Every decision is evaluated against the 90-day monetisation mission: 1,000 subscribers + 4,000 watch hours. Zeus broadcasts the current phase (COLD_START → MOMENTUM → PUSH → MONETISED) and daily briefing. All behaviour — thresholds, urgency, content strategy — shifts based on phase. Never act without knowing the current phase.

---

Core Responsibilities

1. Comment Intelligence      → filter, classify, attribute to agents
2. Performance Monitoring    → YouTube Analytics, video health scores
3. Ad Intelligence           → AdSense earnings, Google Ads CTR/CPV/keyword
                               performance, campaign control, budget guard
4. Agent Scoring             → points engine, weekly/monthly rankings
5. Memory Management         → write lessons to KB, maintain DynamoDB
6. Team Coordination         → brief agents, resolve conflicts, set priorities

Read skills/ads-manager/SKILL.md before building any Zeus ad-related functionality.

Read skills/aria/SKILL.md — Zeus feeds ARIA with internal performance data per theme and reviews the evidence-log weekly to calibrate ARIA's scoring weights.

Read skills/sniper/SKILL.md

Read skills/oracle/SKILL.md

Read skills/the-line/SKILL.md — Zeus no longer reads agent-messages directly. THE LINE synthesises all agent outputs into one morning brief. Zeus reads the zeus-briefs table only. Zeus acts on decisions, does not triage messages.

Read skills/theo/SKILL.md — Theo manages the channel post-upload. Zeus receives Theo's weekly health summary via THE LINE, not directly. — Zeus processes ORACLE_UPDATE messages at every morning briefing, injects knowledge updates into the correct agents, and exposes the ORACLE control panel in Zeus Command Center. — Zeus uses SNIPER's geoStrategy to create geo-targeted campaigns per market instead of one worldwide campaign. Zeus also reads market-performance table weekly to recalibrate which markets to prioritise.

---

Memory Architecture

Zeus owns all four memory stores. No other agent writes to memory directly — they request Zeus to write on their behalf.

Working Memory — DynamoDB

// Tables Zeus maintains:

agent-scores: {
  agentId: "zeus | rex | regum | qeon",
  dailyPoints: number,
  weeklyPoints: number,
  totalPoints: number,
  lastUpdated: ISO timestamp,
  recentWins: string[],     // last 5 positive events
  recentErrors: string[]    // last 5 negative events
}

channel-health: {
  date: ISO date,
  totalViews: number,
  subscriberCount: number,
  avgCTR: number,
  avgWatchTime: number,
  topPerformingVideo: string,
  bottomPerformingVideo: string
}

video-memory: {
  videoId: string,
  topic: string,
  publishedAt: ISO timestamp,
  niche: string,
  agentScores: { rex: number, regum: number, qeon: number },
  performance: { views, ctr, watchTime, commentSentiment },
  lessonsWritten: boolean
}

rex-watchlist: {
  topicId: string,
  topic: string,
  firstSeen: ISO timestamp,
  confidenceScore: number,
  sources: string[],
  checkCount: number,
  status: "monitoring | greenlit | dropped"
}

regum-schedule: {
  date: ISO date,
  slots: [{ time, videoId, status }]
}

Episodic Memory — S3 + Bedrock Knowledge Base

Every significant event stored as a structured episode in S3. Bedrock KB indexes and embeds automatically.

interface Episode {
  episodeId: string;          // ep-{timestamp}-{topic-slug}
  timestamp: string;          // ISO
  agent: "rex" | "regum" | "qeon" | "zeus";
  eventType:
    | "trend_flagged"
    | "content_greenlit"
    | "content_rejected"
    | "video_published"
    | "performance_reviewed"
    | "lesson_learned"
    | "comment_insight"
    | "agent_scored";
  topic: string;
  decision: string;           // what was decided
  reasoning: string;          // why
  outcome: {
    views?: number;
    ctr?: number;
    watchTime?: string;
    commentSentiment?: number;
    subscriberDelta?: number;
  };
  lesson: string;             // one sentence — what to do differently next time
  tags: string[];             // for filtering e.g. ["tech", "apple", "product-launch"]
}

S3 path: s3://rrq-memory/episodes/{agent}/{year}/{month}/{episodeId}.json

Semantic Memory — Bedrock Knowledge Base

// KB configuration
const KB_CONFIG = {
  knowledgeBaseId: process.env.BEDROCK_KB_ID,
  dataSourceId: process.env.BEDROCK_DS_ID,   // points to S3 episodes bucket
  embeddingModel: "amazon.titan-embed-text-v2:0",
  chunkingStrategy: "fixed",
  chunkSize: 512,
  overlapPercentage: 20
};

// Zeus queries KB on behalf of agents
async function recallMemory(query: string, topK: number = 5) {
  const response = await bedrockAgent.retrieve({
    knowledgeBaseId: KB_CONFIG.knowledgeBaseId,
    retrievalQuery: { text: query },
    retrievalConfiguration: {
      vectorSearchConfiguration: { numberOfResults: topK }
    }
  });
  return response.retrievalResults.map(r => r.content.text);
}

// Zeus writes new lessons — triggers KB re-sync
async function writeLesson(episode: Episode) {
  await s3.putObject({
    Bucket: "rrq-memory",
    Key: `episodes/${episode.agent}/${episode.episodeId}.json`,
    Body: JSON.stringify(episode)
  });

  // Trigger incremental KB sync
  await bedrockAgent.startIngestionJob({
    knowledgeBaseId: KB_CONFIG.knowledgeBaseId,
    dataSourceId: KB_CONFIG.dataSourceId
  });
}

---

Comment Intelligence System

Runs every 6 hours for all videos published in last 72 hours. Daily for all videos in last 30 days.

Step 1 — Fetch Comments

async function fetchVideoComments(videoId: string): Promise<Comment[]> {
  const response = await youtube.commentThreads.list({
    part: ["snippet", "replies"],
    videoId,
    maxResults: 200,
    order: "relevance"
  });
  return response.data.items;
}

Step 2 — Zeus Analyses in Batches

Send batches of 50 comments to Opus for classification:

const ZEUS_COMMENT_PROMPT = `
You are Zeus, performance intelligence system for RRQ — an AI-powered YouTube channel.

Analyse each comment and return a JSON array. For each comment:

1. genuine: boolean — is this real human feedback vs spam/bot/promotional?
2. sentiment: "positive" | "negative" | "neutral" | "mixed"
3. category:
   - "topic_quality"       → comment about the subject chosen (Rex)
   - "production_quality"  → comment about video/audio/visuals (Qeon)
   - "research_accuracy"   → comment about facts, data, sources (Rex + Qeon)
   - "topic_timing"        → comment about being early/late on trend (Rex + Regum)
   - "channel_strategy"    → comment about channel overall (Regum)
   - "viewer_request"      → asking for future content (Rex watchlist)
   - "general_praise"      → positive but not specific
   - "irrelevant"          → off-topic, spam, promotional
4. agentAttribution: "rex" | "regum" | "qeon" | "shared" | "none"
5. pointsAward: number — 0 to 3 (0=irrelevant, 1=minor, 2=meaningful, 3=exceptional)
6. insight: string | null — one sentence actionable insight if present, else null
7. isViewerRequest: boolean
8. requestTopic: string | null — if viewer request, what topic they want

Return ONLY a JSON array. No preamble. No markdown.
`;

Step 3 — Points Allocation

function allocatePoints(classifications: CommentClassification[]) {
  const points = { rex: 0, regum: 0, qeon: 0 };

  for (const c of classifications) {
    if (!c.genuine || c.category === "irrelevant") continue;

    const award = c.pointsAward * (c.sentiment === "positive" ? 1 : -0.5);

    if (c.agentAttribution === "rex")    points.rex    += award;
    if (c.agentAttribution === "regum")  points.regum  += award;
    if (c.agentAttribution === "qeon")   points.qeon   += award;
    if (c.agentAttribution === "shared") {
      points.rex   += award * 0.33;
      points.regum += award * 0.33;
      points.qeon  += award * 0.33;
    }
  }

  return points;
}

Step 4 — Viewer Requests → Rex Watchlist

const requests = classifications
  .filter(c => c.isViewerRequest && c.requestTopic)
  .map(c => c.requestTopic);

// Add to Rex watchlist with source "viewer_request"
for (const topic of requests) {
  await addToWatchlist(topic, "viewer_request", 0.3);
}

---

Performance Monitoring

YouTube Analytics Pull (runs daily)

async function pullChannelAnalytics() {
  const analytics = await youtubeAnalytics.reports.query({
    ids: "channel==MINE",
    startDate: thirtyDaysAgo(),
    endDate: today(),
    metrics: "views,estimatedMinutesWatched,averageViewDuration,subscribersGained,annotationClickThroughRate",
    dimensions: "video",
    sort: "-views"
  });

  await updateDynamoDB("channel-health", analytics);
  await writeEpisodeIfSignificant(analytics);
}

Video Health Score

Zeus computes a health score 24hrs and 72hrs after each publish:

Health Score (0-100):
  CTR vs channel average      25 pts max
  Watch time vs channel avg   25 pts max
  Subscriber delta            20 pts max
  Comment sentiment avg       15 pts max
  Shares + saves              15 pts max

Score stored in DynamoDB. Feeds directly into Rex/Regum/Qeon scoring.

Agent Performance Review (runs weekly)

Zeus writes a weekly performance summary per agent:

const ZEUS_REVIEW_PROMPT = `
You are Zeus reviewing weekly performance for agent: ${agentId}

Agent's videos this week: ${videosData}
Comment sentiment data: ${sentimentData}
Analytics performance: ${analyticsData}
Agent's decisions: ${decisionLog}

Write a performance review:
1. overall_score: number 0-100
2. top_win: string — best decision this week
3. top_error: string — worst decision or missed opportunity
4. lesson: string — one concrete thing to do differently
5. trend: "improving" | "stable" | "declining"

Return JSON only.
`;

---

Team Coordination

Memory Injection for Agents

Before any agent starts a task, Zeus injects relevant memories:

async function prepareAgentContext(
  agent: "rex" | "regum" | "qeon",
  task: string
): Promise<string> {
  // Query KB for relevant past lessons
  const memories = await recallMemory(
    `${agent} agent lessons for: ${task}`,
    topK: 5
  );

  // Get agent's recent performance context
  const scores = await getAgentScores(agent);
  const recentWins = scores.recentWins.slice(0, 3);
  const recentErrors = scores.recentErrors.slice(0, 3);

  return `
ZEUS MEMORY INJECTION FOR ${agent.toUpperCase()}:

Relevant past lessons:
${memories.map((m, i) => `${i + 1}. ${m}`).join("\n")}

Your recent wins (keep doing these):
${recentWins.join("\n")}

Your recent errors (avoid these):
${recentErrors.join("\n")}

Current team score: ${scores.teamAverage}/100
Your score: ${scores.agentScore}/100
`;
}

Conflict Resolution

When Rex and Regum disagree on a greenlight decision, Zeus arbitrates:

const ZEUS_ARBITRATION_PROMPT = `
Rex's assessment: ${rexAssessment}
Regum's assessment: ${regumAssessment}
Channel memory context: ${memories}
Current channel health: ${channelHealth}

Make the final call. Return:
{
  "decision": "greenlight | delay | reject",
  "reasoning": "string",
  "conditions": "string | null"
}
`;

---

Zeus Scheduled Runs

Every 30 min:   Check if any agent needs memory injection
Every 6 hours:  Comment analysis batch for active videos
Every 24 hours: Channel analytics pull + video health scores
Every 72 hours: Full performance review for videos published 72hrs ago
Every week:     Agent performance review + lesson writing
Every month:    Deep memory consolidation — identify macro patterns

---

Zeus Dashboard Data Contract

Zeus exposes this to the frontend:

interface ZeusDashboard {
  agentScores: {
    rex:   { score: number; trend: string; lastWin: string };
    regum: { score: number; trend: string; lastWin: string };
    qeon:  { score: number; trend: string; lastWin: string };
    team:  { score: number; trend: string };
  };
  channelHealth: {
    viewsToday: number;
    subsGained: number;
    avgCTR: number;
    avgWatchTime: string;
  };
  commentInsights: {
    analysed: number;
    genuine: number;
    topRequest: string;
    topPraise: string;
    topComplaint: string | null;
  };
  memoryLog: {
    agent: string;
    lesson: string;
    timestamp: string;
  }[];
  watchlist: {
    topic: string;
    confidence: number;
    status: string;
  }[];
  recentEpisodes: Episode[];
}

Council Sign-Off Protocol

Zeus is the final operational sign-off on every video. He receives the council brief from The Line only after all six domain sign-offs are green (or flags acknowledged). Zeus never sees a messy argument — he sees a clean brief.

Zeus's sign-off is not creative approval.
Zeus is asking one question: "Is this operationally sound?"

If yes → "Approved. Ship it to production."
If no  → "Send back. [specific operational concern]."

Zeus does not override domain expertise.
Zeus does not tell Muse the sequence is wrong.
Zeus does not tell Rex the timing is off.
If Zeus has a domain concern — he routes it back to
the relevant agent via The Line, not directly.

Deadlock Resolution

When two agents cannot agree and the deadlock reaches Zeus + Jason:

Zeus's role:    Domain weight decision
                Which agent's concern carries more weight
                for THIS video, THIS niche, THIS moment?

Zeus rules by:  Evidence from the council index
                Historical precedent from Oracle
                Mission priority — Alpha or Beta?
                Operational risk assessment

Zeus's ruling:  Always includes reasoning — logged permanently
                The overruled agent's concern is preserved,
                never erased. If the video performs badly
                in exactly the predicted way — the RRQ Retro
                will surface it and adjust future council weights.

Zeus's deadlock ruling format:

"I am ruling in favour of [agent] on this deadlock.
 Reasoning: [specific, evidence-based].
 [Overruled agent]'s concern about [X] is noted and logged.
 If this video underperforms in the way [overruled agent] predicted,
 the RRQ Retro will revisit this ruling.
 Proceeding to production."