Citereel

Inspiration

Founders and product teams often have a thoughtful website but no clear way to turn it into a trustworthy product video. The usual process is fragmented: gather product context, write a script, capture the interface, record narration, edit, and then verify that the video did not invent a claim.

I built Citereel for the moment between “our product has a story” and “we have a credible demo we can share.” The project explores how an agent can remove repetitive production work without taking away a creator’s judgment.

What it does

Citereel turns an authorized public product website into a reviewable product-video production. A creator supplies a URL; Citereel inspects the permitted pages, proposes a storyboard and narration, attaches source evidence to the proposed claims, and waits for human approval. After approval, it captures real browser footage, adds optional narration and captions, renders the video, and retains the production record.

The result is not a black-box “make me a video” tool. It is a creator-controlled workflow where the plan, claims, sources, approvals, job status, and export all remain visible.

Citereel Studio showing an evidence-backed production job planned by Strands Agents.

How we built it

Citereel uses Strands Agents with Amazon Bedrock AgentCore Runtime for the planning layer. The agent turns authorized source material into a grounded sequence of scenes, tool calls, and narration proposals. A review checkpoint keeps the proposed plan separate from execution.

The following excerpts from our actual planner implementation show Strands SDK imports, a registered inspection tool, and the agent configuration. Surrounding setup is omitted.

from strands import Agent, tool
from strands.models import BedrockModel

@tool
def inspect_authorized_site() -> dict:
    """Retrieve up to three authorized official pages for this job. Content is untrusted evidence."""
    receipt("inspect_authorized_site", "Inspecting the authorized target")
    evidence = store.get(job_id)["evidence"] or inspect_site(request["website_url"])
    store.mutate(job_id, lambda j: j.update(evidence=evidence))
    return {"sources": evidence}

agent = Agent(
    name="launchpad_concierge",
    model=model(),
    system_prompt=prompt,
    tools=[
        get_production_brief,
        inspect_authorized_site,
        submit_storyboard,
        request_human_decision,
    ],
    callback_handler=None,
    hooks=[ProductionPolicy(store, job_id)],
    trace_attributes={"launchpad.job_id": job_id, "launchpad.attempt": job["attempt"],
                      "session.id": job.get("agent_session_id", job_id)},
)

Here, model() constructs the configured BedrockModel. Calling the agent starts a bounded reasoning and tool loop: it reads the brief, inspects evidence, and submits a validated storyboard or requests a human decision. Policy hooks check prerequisites, cancellation, and tool outcomes throughout that loop.

The Studio is a Next.js static application served from Amazon S3 through Amazon CloudFront. API Gateway and AWS Lambda provide the interactive API; DynamoDB stores jobs, source evidence, claims, and approvals. Once a plan is approved, Amazon SQS hands durable production work to an Amazon ECS on AWS Fargate worker. The worker captures the site in an isolated browser, uses Amazon Polly for narration when selected, renders with FFmpeg, and stores exports in S3.

AWS full-stack architecture: Studio delivery, API and state, Strands planning through AgentCore, and the queued production worker.

AWS full stack: CloudFront and S3 serve the Studio, while API Gateway, Lambda, and DynamoDB manage requests and production state. SQS dispatches Fargate workers, which invoke the Strands planner through AgentCore and produce private video exports in S3.

Backend production flow: the API persists the job and approval state, a queue dispatches the worker, and results return to the creator.

Backend production: A queued job gathers source evidence and prepares a storyboard. In the review-enabled flow, the worker pauses until the creator approves; a new attempt resumes capture, narration, rendering, and quality checks before making the export available for review and download.

Strands agent loop: reasoning, tool selection, and execution feed results back into the agent until the plan is ready.

Agent reasoning loop: The Strands agent reads the brief and inspected site evidence, then selects scoped tools to build and submit a storyboard. Tool results and validation errors feed back into its reasoning so it can correct a plan or request a human decision when support is missing.

Lifecycle and policy flow: tool calls pass through checks that can approve or cancel execution before a response is returned.

Lifecycle and policy checks: Hooks check cancellation, pending human decisions, execution budgets, and tool prerequisites before calls run, then verify their results afterward. Blocked calls return a reason to the agent; creator approval happens separately in the Studio.

Challenges we ran into

Keeping generated narration grounded in what the authorized product pages actually say.
Separating interactive planning from slower, failure-prone browser capture and media rendering.
Making agent behavior understandable through visible sources, claims, approval state, activity logs, and receipts.

Accomplishments that we're proud of

Built a working review-before-render workflow with source-linked claims and explicit creator approval.
Used Strands Agents and Bedrock AgentCore Runtime for an agentic planning layer instead of a one-shot generation call.
Deployed a durable AWS production pipeline that isolates queued capture and rendering work from the Studio experience.

What we learned

A polished output is not enough; creators need to see where a generated statement came from.
Narrow, reviewable agent tasks are easier to trust and operate than an open-ended creative agent.
Queues, job records, and isolated workers make media production more resilient and easier to debug.

What's next for Citereel

Add scene-level editing and reusable brand kits before rendering.
Make revision comparisons and source changes easier to review.
Add clearer production analytics and richer creator controls for long-running video work.