watchable

AI UGC video ads for DTC/ CPG- 2x faster & cheaper

Comment

Inspiration

DTC brands and performance marketing teams need a constant stream of video ads that convert. The production pipeline is broken — agencies charge $2,000- $10,000 per video and take weeks. UGC creator networks are unpredictable. And every AI video tool (Arcads, Google Flow) skips straight to generation, assuming the marketer already knows exactly what to say. They don't. And that's the real problem. Eugene spent 10 years as a CMO producing tens of thousands of digital video assets per month for brands like Coca-Cola and Nestlé. He ran 20+ interviews with marketing teams before we wrote a single line of code. The answer was always the same: "The tools can generate footage. They can't think." 80% of ad performance is determined at the brief stage — not the render stage. Better footage of a bad concept still performs badly. We set out to solve the thinking layer.

What it does

Campaign Agent is a standalone autonomous service that pulls real brand data, writes the creative brief, and generates a storyboard — so marketers skip the setup and start reviewing. Campaign Agent is a new project built for this hackathon. It runs as a separate service and plugs directly into Watchable — the chat-first AI storyboard workspace for enterprise marketing teams. The user opens Watchable and clicks one button: Import Brand & Generate Storyboard. Campaign Agent takes over from there: Airbyte ingests live brand context from connected data sources — Ghost articles, product pages, campaign docs — and syncs it into a structured data layer the agent can reason over. The agent knows your brand before you say a word. Auth0 gives the agent its own machine-to-machine identity. It authenticates autonomously against every downstream API without a human ever logging in mid-workflow. The agent acts under its own verified credentials — it can run overnight, on a schedule, without anyone watching. The agent reasons through the brand context, extracts product, audience, tone, hooks, and CTA direction, and generates a complete creative brief with 4–6 storyboard scenes. The result lands inside the Watchable project workspace for the marketer to review and refine through chat. On approval, Campaign Agent publishes the final brief to Ghost as a structured, shareable brief page — ready for the production team to act on immediately.

Brand data in. Storyboard brief out. Published link delivered. Zero manual briefing.

How we built it Two repos, one product: campaign-agent — new standalone Python/FastAPI service built at this hackathon ugc + ugc_server — Watchable frontend and backend (existing product)

Stack:

Campaign Agent (new): Python, FastAPI, LangGraph, Auth0 M2M, Airbyte Cloud API, Ghost Admin API, Claude Opus 4.6 How Campaign Agent works internally: We built a four-node LangGraph graph: Ingest Node (Airbyte) — reads the latest synced brand content snapshot from the Airbyte data layer. Airbyte pre-syncs Ghost content on a schedule, so the agent reads a fresh snapshot without waiting for a live sync during the run. Decide Node — the agent scores and ranks the ingested content by relevance to the current campaign goal and trims to a focused context window. This decision step is what makes it a graph, not just a pipeline — if context is too thin, the agent flags gaps and requests input rather than generating generic output. Generate Node (LLM) — two sequential LLM calls: first to extract the structured brief (product, audience, tone, hook, CTA), then to generate 4–6 storyboard scenes from the brief. Deliver Node (Auth0 + Ghost) — agent requests a fresh Auth0 M2M token, attaches it to the outbound Ghost Admin API call, and publishes the final brief. The author on the Ghost post is "Campaign Agent" — not a human. Watchable adds one button and one API call. Everything else runs inside Campaign Agent. We also published Campaign Agent as a skill on Shipables.dev so other agents can call production-grade creative brief generation as a composable module.

Challenges we ran into

Context window vs. brand context depth. Airbyte can pull a lot of data. We had to build the Decide node specifically to rank and trim incoming brand content by relevance to the campaign goal. Too much context made the storyboard generic; the right amount made it feel like the agent had actually read the brand playbook. Auth0 M2M in an agent loop. Standard OAuth flows assume a human in the loop for token refresh. We had to implement a token caching and silent-refresh layer so the agent doesn't stall mid-run waiting for a credential exchange — especially important for scheduled overnight runs. Ghost content structure. Ghost's content model is article-shaped — it wasn't designed for structured storyboards with shot-by-shot breakdowns. We built a custom serializer that maps our storyboard schema (hook, scenes, CTAs, format metadata) into Ghost's Lexical JSON format so the published brief renders cleanly. Airbyte sync timing. A live sync during a demo is a dead demo — Airbyte Cloud syncs take 30–90 seconds. We redesigned the flow so the agent reads a pre-synced snapshot rather than triggering a live sync, and built in a cache fallback so the demo never stalls.

Accomplishments that we're proud of

Built a working end-to-end autonomous agent in one sprint: brand context in → storyboard out → published brief, zero human steps in between. The Auth0 M2M integration means the agent can run on a schedule — a marketer could wake up to 5 ready-to-produce briefs every morning, auto-generated overnight from live brand data. Campaign Agent is deployed as a standalone service with a clean API contract — any product can call it, not just Watchable.

What we learned

Autonomy is a systems problem, not a model problem. The hardest part of making an agent genuinely autonomous wasn't the LLM reasoning — it was the infrastructure around it: credential management, context sizing, graceful failure handling, idempotent publishing. Auth0 M2M was the right call and more nuanced than we expected. Sync timing matters as much as logic. You can have perfect agent reasoning and still fail the demo because your data layer takes too long to respond. Designing for pre-synced snapshots instead of live pulls was the right architectural decision — and one we'll carry into the production product. Structure before generation is a universal principle. We built Watchable to solve the brief layer for video ads. But every team we talked to today had the same underlying problem: they need an agent that thinks before it does. Campaign Agent is that pattern, deployed as a service.

What's next for Watchable

Performance feedback loop — connect ad performance data (CTR, ROAS by creative) back into Campaign Agent via Airbyte so the storyboard generator learns which hooks and angles actually convert for each brand over time. Paid pilots in Q2 2026 — converting our three enterprise testers to paying contracts. Multi-agent architecture — the creative brief agent, the brand context agent, and the publishing agent running as independent workers on a shared LangGraph graph, so large brands can run parallel campaigns across multiple products simultaneously. Pre-seed raise — $500K to accelerate enterprise sales and grow the model training dataset from real campaign performance data.

Built With

Share this project:

Updates