It's time to set up your holiday streaming campaign
Are you ready to reach holiday shoppers on CTV? For many streamers, the season is already underway.
Last year, according to Roku internal data, holiday content searches on Roku saw an 86% increase during October. And in November, those searches rise an average of 39% weekly. This surging holiday spirit is mirrored by consumer activity, as about half of Roku streamers shopped Black Friday and Cyber Monday deals in 2025.
Meeting those shoppers is easier than you might think. Begin with the seasonal outcome you hope to drive: awareness, online sales, leads, store visits, or another measurable goal. From there, define your audience, upload your creative, set the budget and campaign dates, and establish measurement before launching. You can even create a shoppable ad unit that lets streamers buy with a click of their remote.
Our holiday playbook offers a month-by-month guide to reaching shoppers during this all-important time of year.
First-time spenders get a $5,000 match on the first $5,000 spent with code BEEHIIV5K. Terms apply.
You're getting this because you subscribed to The AI Hatchery. Not for you anymore? Unsubscribe in one click.
Hi there,
An agent that handles customer support sounds like one job. Answer a question, look up an account, sort out a bill.
Those are different jobs. Giving all of them the same prompt and the same tools is a design choice, not a requirement.
This week, let's take that design apart. Not a tour of another framework. A small support workflow you can sketch before writing the agent loop.
The useful question is: which decisions need the model, and which ones already have an answer in your application?
One inbox doesn't need one agent
Anthropic's Building effective AI agents makes a distinction worth keeping: workflows follow predefined code paths; agents let the model choose its process and tools as it goes.
Its routing pattern classifies an input and sends it to a specialized follow-up task. Customer support is one of the examples: general questions, refund requests and technical support can go to different downstream processes.
That's vendor guidance, not evidence that routing wins for every inbox. But it gives you a useful starting point when your requests fall into distinct categories.
You don't have to decide that your whole product is a workflow or an agent. A fixed route can lead to a task that needs an agent. Another route can end in an ordinary lookup.
Start with the jobs, not the worker names
Here's an illustrative support inbox, not a system I've deployed:
Documentation question: find the relevant docs and draft an answer with the source.
Billing question: identify the account and request, then follow the billing process.
Technical problem: collect the error and the information needed to investigate it.
Unclear or mixed request: ask a clarifying question or send it for review.
“Billing agent” isn't enough of a specification. Does it explain an invoice, change a payment method or issue a refund? Those are different outcomes.
Write what each branch should return. A documentation branch might return a draft answer and its supporting URL. A billing branch might return a case summary. A technical branch might return the error, relevant environment details and the next diagnostic question.
Now you have something concrete to connect. You also know what the next step is waiting for.
Let the model classify. Let code dispatch.
The first model call doesn't need to solve the ticket. Give it the narrower job of classifying the request.
For example, it could propose:
{
"route": "technical",
"reason": "The customer reports an error when importing a CSV."
}
Your application checks that the proposed route is one it supports. Then it chooses the handler. The explanation is useful to inspect, but it isn't proof that the route is right.
Here's the shape of the dispatch, in pseudocode:
proposal = classify(request)
if proposal.route is not an allowed route:
return needs_review(request)
return handlers[proposal.route](request)
This is an illustration, not tested integration code. In a real implementation you still need to define the response format, validate it and handle failures.
The important part is the division of work. The model proposes a category. The application maps that category to a known process. A generated handler name doesn't become executable just because it looks plausible.
Keep “I don't know” as a real route
A customer writes: “The import failed, and I want a refund.”
Is that technical support or billing? Both. If your classifier has to pick one, you've made it hide part of the request.
Decide how the product should handle that case. It could ask which problem the customer wants to address first. It could create two linked tasks. It could send the request to a person who can handle both.
There isn't one correct policy for every business. There should be an explicit policy for yours.
Keep unclear and mixed requests in the design from the start. Otherwise, your tidy diagram only works on the tickets you drew it for.
Don't pass every branch the whole inbox
Once the route is chosen, give the handler the information its job needs.
The documentation branch needs the question and relevant documentation. The billing branch may need an account lookup and the billing process. The technical branch needs the error and environment details.
That doesn't mean three independent workers need to read every ticket from scratch. You can pass the original request plus the fields needed for that branch. Preserve the original wording so a classifier's summary doesn't silently replace what the customer asked.
And if several branches contribute to one answer, name the step that combines their outputs. Three completed tasks are not automatically one coherent customer response.
Check the boundary cases before adding more branches
Try a plain documentation question, a clear billing request, a technical error and a mixed request. Add one that doesn't belong in any category.
For each, inspect two things: where it went, and whether that branch returned what the next step needed.
If it chose the wrong route, look at the category definitions. If it chose the right route but couldn't complete the job, look at that handler's input and output. Those are different fixes.
Don't add five more worker names to solve an unclear boundary between two jobs.
Try this week: take one broad agent prompt and draw its dispatch table. For every route, write the input, expected output and what happens when the request doesn't fit. Leave the number of branches small until you can explain why each one exists.
The takeaway isn't “replace every agent with a workflow.” It's this: keep the known parts of the job explicit, and give the model the decisions that actually need judgment.
Sources and scope are on the web version.
Latest Season1 explainers
"Open model" means 3 things · Published November 18, 2026.
Downloadable weights, permissive licensing and training transparency answer different questions; check the actual artifacts and terms before choosing a model.
MCP vs a Plain API Call: What the Protocol Actually Adds · Published November 16, 2026.
MCP standardizes tool discovery and integration, but your application still executes the calls and remains responsible for authorization and review.
Attention, Explained with a Worked Example · Published November 13, 2026.
Follow one query through scaled scores, softmax weights and a weighted mix of values, then see why dense attention’s pairwise workload grows with context length.
Community projects
Awaiting the current thread ranking before sending. The three projects below are the last verified snapshot of the November 11 weekly project display thread's Top view, excluding AutoModerator, checked November 11, 2026, at 2:41 p.m. Pacific. The current Top order could not be verified on November 18, so these are not presented as today's top three. Reddit ordering is not a quality endorsement; we haven't independently tested these projects.
1. Stackboard
Stackboard turns Chrome bookmarks into a draggable new-tab board. The builder also reports a coding-agent workflow around the product that checks community replies, records feature requests and helps produce content, with fixed activity caps; that workflow isn't a tested feature of the extension.
2. Quantradin
Quantradin documents an MCP-connected paper-trading desk where agents can develop strategies, run backtests and manage simulated bots. It uses simulated money, holds no funds and routes no exchange orders; we haven't evaluated its backtests or financial performance.
3. Silos
Silos is an open-source CLI for running local agents in Docker sandboxes, with policy-controlled network access, host-side credential handling and audit logs. Its README stresses that this reduces risk, not that arbitrary agent code becomes safe; installation is currently from source, not npm.
Yujian
P.S. Which part of your agent's job could be an ordinary workflow? Hit reply and tell me.
Want to choose which Hatchery emails you get? Update your preferences.
Sources and scope
Anthropic, Building effective AI agents. Source rechecked November 18, 2026. The source distinguishes workflows from agents and describes routing to specialized follow-up tasks, including customer support. Its current introduction notes that tooling has changed since December 2024. This piece uses the architectural pattern, not historical tool or model recommendations.
Latest Season1 recap sources, checked November 18, 2026: #4: “Open model” means 3 things (published November 18); #3: MCP vs a Plain API Call (published November 16); #2: Attention, Explained with a Worked Example (published November 13). All three are published canonical articles with readable public pages.
The support inbox, categories, output shapes and pseudocode above are illustrative design guidance. They are not a company teardown, a report of personal deployment experience, a tested tutorial or a guarantee of routing accuracy. No new product release or performance claim is made.


