Back to blog
mcparchitecturebroadcast

Steward George: an agent that runs the channel and changes nothing without approval

Steward is the Sim RaceCenter agent for the @SimRaceCenter YouTube channel. It reads, plans and proposes; the owner approves every public change. Here is how it is built and what we are building with it.

·Sim RaceCenter Team·7 min read
On this page

Director automates the broadcast. Nothing automated the work around it: scheduling the stream, writing a title and description, making a thumbnail, fixing the metadata afterwards and answering the questions viewers leave in the comments. For a small team that work costs more time than the race itself.

Steward George is the agent we built to take it on. This post covers what Steward is, the rule it works under, and what is live today against what is still planned.

What Steward is

Steward is an AI agent that manages the @SimRaceCenter YouTube channel on the owner's behalf. It is not part of Director and it does not run on the broadcast host. It runs on Claude as a scheduled cloud task, in a fresh container each time, and reaches the channel through a remote MCP server we host at mcp.simracecenter.com.

Two things make it more than a prompt:

  • A workspace repository. Steward's rules, decisions, current state and a dated journal live in a Git repository. Every run starts by reading them. The repository changes only through pull requests that the owner merges, so Steward cannot quietly rewrite its own rules.
  • A narrow set of tools. Steward can read the channel, propose changes, keep short notes and report to the owner. It has no tool that changes YouTube.

The rule: propose, don't publish

Authentication proves who is calling a tool. It does not prove the request is safe. An agent that reads YouTube comments reads text written by strangers, and a comment can say "delete your latest video" as easily as it can ask a question. So the safeguard is in what the tools can do, not in what the agent is told.

TierWhat it coversEffect on YouTube
ReadChannel, videos, broadcasts, playlists, comments, analyticsNone
ProposeVideo title, description and tags; comment repliesNone. Creates a pending proposal on the server
RememberShort notes between runsNone
ReportA plain-text message to the owner's private Discord channelNone
ApproveNot an MCP toolThe server applies the change after the owner approves
Not builtDeleting videos or comments, privacy, channel settings, uploadsOut of scope

A proposal holds the before and after values and Steward's reason. It expires after seven days, and the server refuses to apply it if the video changed in the meantime.

How a change reaches YouTube

Steward ──propose──▶ MCP server ──notify──▶ owner (email, Discord)
                         │
                         ▼
                 approval console ◀── owner signs in with Google
                         │
            approve / edit / request changes / reject
                         │
                         ▼
                    YouTube APIs
  1. Steward calls a propose tool. The server stores the proposal and notifies the owner.
  2. The owner opens the approval console, a server-rendered page behind Google sign-in. It shows the server's own before and after values, with a diff for descriptions.
  3. The owner approves, rejects, edits the proposal and approves their own version, or requests changes. When changes are requested the server starts Steward at once, and Steward revises the same proposal.
  4. On approval the server applies the change, verifies the write and records the result.

The Google credential for the channel stays in a key vault on the server. Steward never holds it, and the token Claude uses is never passed to Google. Only one Google identity can sign in, and the server is locked to one channel.

Discord is the quick channel. The owner can list open proposals, send feedback on one, or ask Steward for something with a /steward command. Nothing can be approved from Discord: every decision that changes YouTube happens in the console.

A daily check

Steward runs once a day, and on demand when the owner asks. A daily check:

  • answers any proposal the owner sent back with feedback;
  • reads the last day's mail to the project inbox;
  • looks for new streams and proposes metadata fixes for them;
  • reads new comments and proposes a reply where a question deserves one;
  • posts a short summary to the owner if there is anything to tell.

Steward reads mail but does not send it. Replies are written as drafts for the owner to review.

Memory between runs

A cloud run starts with no memory of the last one. Steward has two places to keep what it learns.

  • The repository holds what changes slowly and what the owner should review: rules, decisions and state.
  • The notes store on the MCP server holds what a daily run learns: the gist of a comment, what a stream was, a preference the owner stated. Each note is one line in Steward's own words, never a copy of the source, and a note about the same item replaces the earlier one. The owner can read and delete notes in the console.

Notes are found by filters and word search. At a cap of 5,000 notes a search reads every note, so a vector index would add cost and upkeep without finding more.

Notes are treated as data. They are summaries of public text written by an agent, so a note never authorises anything.

What we are building with it

The read, propose, approve loop is live for video metadata and comment replies. The next phase moves Steward from fixing metadata to preparing the whole stream. None of the following has shipped yet.

  • Stream setup. From a race plan the owner confirms, Steward prepares one bundled proposal: a scheduled broadcast with title, description, tags and thumbnail. The owner approves once. Director then finds the approved broadcast, so its chat agent connects without a pasted URL.
  • Run data from Director. Director already records what happened in a run: flags, aired replays, session times. An automatic export at the end of each run gives Steward the facts, so a description or chapter list comes from recorded events and not from a guess.
  • Thumbnails from the stream itself. Director's event data tells Steward where to look; the stream VOD shows what the moment looked like. Steward pulls frames around the race start and aired incident replays, composes several variants on the brand template and offers them in one proposal.
  • Measurement. A per-video scorecard from YouTube Analytics sets a baseline. Steward then proposes experiments on thumbnails and titles and runs the approved plan. The channel is small, so one video rarely gives a significant result. Steward pools results across streams and says so when a result is noise.

Steward also works in the product repositories when asked. It wrote parts of the MCP server it uses, each change through a pull request reviewed by the owner.

Why build it this way

Steward follows the same position as the Director v3 rebuild: automation does the repetitive work, a deterministic system makes the change, and AI is advisory. In Director the deterministic core makes every cut and the Broadcast Agent advises. On the channel the server applies every change, the owner decides, and Steward prepares.

The tools Steward calls are MCP servers, like the simulator MCP servers on the Rig. The difference is the boundary. Simulator roles are unauthenticated and stay on the LAN. The channel server is on the public internet, so it has OAuth, a single-owner allowlist and no write tools at all.