SponsorLint Autopilot

An agentic QA loop that finds sponsor-read violations, creates evidence-linked retake plans, and re verifies every new cut without letting AI change the approved brief.

Comment

SponsorLint Autopilot

From a rejected sponsor cut to a verified retake.

The problem

Sponsor integrations look simple until you have to satisfy an actual brief.

A creator may need to say the exact product name, use the correct discount, include a tracked URL, place a disclosure correctly, stay inside a duration window, avoid prohibited claims, and satisfy visual requirements — all in one short recording.

One mistake means another review cycle with the brand.

SponsorLint already answered:

"Before I send this sponsor cut, did I actually follow the brief?"

For Agentic Day, we wanted to answer the harder question:

"If I failed the brief, what should I do next — and can an agent safely drive that correction loop without quietly changing the rules?"

That became SponsorLint Autopilot.

What it does

SponsorLint turns a sponsor brief into a human-approved executable specification and deterministically checks a recorded sponsor segment against it.

Autopilot sits on top of that verifier.

When a take fails, Autopilot:

  1. Inspects the real verification report.
  2. Understands which requirements failed, warned, or still need manual review.
  3. Plans the smallest safe set of retake actions.
  4. Produces an evidence-linked retake checklist tied back to the approved sponsor brief.
  5. Waits for an actual corrected take from the creator.
  6. Runs the existing deterministic verifier again.
  7. Observes what improved and what still failed.
  8. Decides whether to finish, create another bounded iteration, or escalate to a human.

The loop is:

Goal → Understand → Plan → Act → Observe → Decide → Act Again → Verify

Autopilot is deliberately bounded rather than endlessly autonomous.

It does not rewrite the sponsor brief, weaken requirements, edit a transcript and pretend it is a new recording, suppress failures, or automatically approve human-review requirements.

A concrete example

In our bundled campaign, the first take legitimately fails multiple sponsor requirements.

Instead of just showing a red report, Autopilot turns those failures into a retake plan:

  • what requirement failed
  • what the approved brief actually expected
  • what was detected
  • the evidence that caused the finding
  • the smallest recommended correction
  • whether a human still needs to verify something

The creator then supplies a genuinely corrected take.

Autopilot invokes the same real verifier again and compares the new result.

If automated requirements pass but a visual requirement still needs a person, Autopilot stops at NEEDS_HUMAN_REVIEW.

Only explicit human confirmation through the trusted path can allow the existing readiness resolver to reach SPONSOR_READY.

That separation is intentional.

What makes it agentic

We did not want to build another prompt-in / response-out chatbot.

Autopilot is a bounded workflow agent with explicit backend states:

INSPECTING → PLANNING → WAITING_FOR_RETAKE → VERIFYING_RETAKE → NEEDS_HUMAN_REVIEW / COMPLETE / ESCALATED

Its visible trace is generated from real backend state transitions rather than a scripted progress animation.

It uses tools, observes their results, changes its next action based on those results, and can perform another verification cycle when the first correction is insufficient.

Most importantly, the agent cannot declare its own work correct.

The deterministic verifier remains the source of truth.

The trust boundary

Our core design principle is:

AI proposes. Humans approve. Deterministic code verifies.

The AI-assisted compiler can propose a specification from a sponsor brief, but a human approves that specification before verification.

Autopilot can reason about failures and recommend the next action, but it cannot modify that approved contract to make a recording pass.

Verification itself remains deterministic.

This gave us something more useful than a fully autonomous marketing agent: an agent that knows where its authority ends.

What existed before the hackathon

SponsorLint itself was an existing project.

Before Agentic Day, it already supported:

  • compiling sponsor briefs into proposed specifications
  • human approval of those specifications
  • deterministic sponsor-read verification
  • timestamped PASS, WARN, FAIL, and MANUAL REVIEW evidence
  • DO_NOT_SEND, REVIEW, and SPONSOR_READY readiness states
  • a CLI and browser workflow
  • a reproducible zero-key sample campaign

We are explicitly preserving that provenance rather than presenting the entire system as hackathon-day work.

What we added during Agentic Day

The hackathon contribution is SponsorLint Autopilot:

  • the bounded retake agent/controller
  • explicit agent states and backend-generated trace events
  • evidence-grounded retake planning
  • iteration tracking and safe stopping
  • real corrected-take submission
  • deterministic re-verification from inside the agent loop
  • result comparison and next-action decisions
  • human-review escalation that the agent cannot bypass
  • the Autopilot experience integrated into the existing report UI

In short:

failed cut → evidence → retake plan → real corrected take → re-verification → human escalation or verified completion

How we built it

SponsorLint is primarily a Python application using FastAPI, Pydantic, Jinja2, vanilla JavaScript, HTML and CSS.

The verifier consists of deterministic validators for requirements such as:

  • MUST_SAY
  • MUST_NOT_SAY
  • EXACT_VALUE
  • MUST_DISCLOSE
  • DURATION
  • URL_OR_CTA

Anything the deterministic verifier cannot truthfully determine is surfaced for manual review instead of being guessed.

For real media workflows, SponsorLint can use faster-whisper for transcription and ffmpeg for media inspection. The bundled judging path is intentionally reproducible without an API key, model download, ffmpeg, or network dependency.

We also built regression tests around the trust boundary so that Autopilot cannot silently mutate the approved specification, fabricate successful verification, bypass manual review, or return SPONSOR_READY independently of the existing readiness resolver.

Challenges we ran into

Making an agent useful without giving it too much authority

The easiest implementation would have been to let an LLM rewrite failing text until it matched the expected answer.

That would also destroy the reason SponsorLint exists.

We instead had to separate recommendation from verification. Autopilot may tell the creator what needs another take; only real evidence can make the finding pass.

Making the agent trace truthful

A polished animated "agent is thinking..." timeline is easy to fake.

We wanted every visible Autopilot event to correspond to something the backend actually did, so states and trace entries are produced by executed transitions.

Preserving human-only requirements

Visual requirements are particularly important. SponsorLint currently does not pretend to perform visual verification. Those checks remain explicit human work even when every automated requirement passes.

What we learned

The biggest lesson was that agentic does not have to mean putting an LLM in every step.

A useful agent can orchestrate deterministic tools, inspect structured evidence, make bounded decisions, request missing human input, retry when necessary, and know when to stop.

For a compliance-oriented workflow, that restraint is a feature.

Autonomy becomes much more useful when the system can also explain what it knows, what it recommends, what was actually proven, and what remains outside its authority.

Mel

Mel was used as the agentic development environment for the hackathon build.

Three ways Mel helped

  1. Kept Claude Code grounded in the real SponsorLint repository and architecture.
  2. Made the build → test → debug → review loop much faster.
  3. Helped review Autopilot for trust-boundary and verifier-bypass issues.

Three issues / friction points

  1. Long coding sessions required occasional context restating.
  2. Judge-ready screenshots/evidence still had to be collected manually.
  3. Context did not always transfer smoothly between terminal and Mel-native review.

Feature request for Mel

Automatically generate a shareable build timeline linking prompts, diffs, test runs, failures and fixes.

What's next

The current focus is intentionally narrow: make the sponsor retake loop trustworthy before making it broader.

Future work could include stronger visual evidence tooling, durable run storage, richer media analysis, and integrations into creator editing workflows — while preserving the same boundary:

the agent can help you fix the work, but it cannot move the goalposts or certify itself.

Built With

Share this project:

Updates