Compliance by TwelveLabs: Faster Content Review, With the Judgment Left In

Compliance by TwelveLabs is a video compliance review application that checks region-specific rulesets against footage and flags violations for human review.

Ask a media compliance team what they do and they won't describe a detection task. They'll describe a judgment call with a deadline.

A two-hour master arrives. It has to clear for a dozen territories, each with its own regulator, its own age ladder or watershed schedule, and its own view on what context excuses what. Someone watches the whole thing at real speed, logging timecodes into a spreadsheet, working from a ruleset that lives in a PDF. Then the next title. Then the same title again, for the next territory.

None of this work is hard to get right. It's hard to do quickly, at volume, when being wrong means a fine, a takedown, or a licence.

That's the problem Compliance by TwelveLabs was built for.

Why we built it

For the past two years, nearly every enterprise conversation we've had has ended at the same question: can you give us the application, not just the API?

Our honest answer used to be sort of. A notebook, a reference architecture, a partner integration. That's enough while a team is exploring what a model can do.

It stops being enough when they try to operationalize it. The distance between a working endpoint and a working business outcome is wider than it looks, and very little of it is model work. It's the workflow the output has to fit into, the rules it gets measured against, the evidence someone needs before they can act on it, and the proof that a change made things better rather than worse. Most teams don't want to build that layer, and they shouldn't have to.

Meanwhile, compliance teams were telling us the same thing about the AI tools already on the market. The tools flag plenty. But they flag so much that reviewers stop trusting the output and scrub the full timeline anyway, which means the tool has added a licence fee without removing the review hours.

There's a second, quieter frustration. In most of these products the rules are baked in. You get a vendor's interpretation of a regulator's guidance, and you can't inspect it, edit it, or override it. For a team whose entire professional value is their reading of that guidance, being asked to sign off on someone else's black box is a hard sell.

Both problems come from the same place. "There's a knife at 14:22" is a detection result. A compliance finding is a different kind of statement: does this cross the line, in this territory, for this audience, in this slot. That depends on the ruleset, not on the pixels.

So we built the application ourselves. Media and entertainment focused first, because compliance there is high-volume, high-stakes and fragmented across territories in a way that makes the case obvious.

What it does

You point it at an asset and run a video content review against one or more rulesets. A two-hour master comes back in minutes rather than in a viewing day.

Findings arrive at a timecode, with their evidence. Every flagged moment carries what was seen, what was heard, what was said, a one-line rationale, and the band it was graded at. The reviewer clicks a moment and lands on the beat. They're not searching for the problem; they're deciding about it.

The timeline shows the clean categories too. There's a lane for every category the ruleset scanned, including the empty ones. Knowing what was checked and came back clear is part of the job.

Every regime is a ruleset you can open. 45 ship with the product, covering film and video classification boards, broadcast regulators and scheduling regimes. You can clone one, edit the criteria, or import your own guidance document and have a draft pack generated from it. Plenty of the demand isn't a regulator at all: a studio's internal standards, a platform's brand-safety policy, an advertiser's acceptable-content list.

Findings become work orders. A ruleset can attach a remediation to a band: cut, blur, bleep, blackout, content warning, subtitle redaction. A review stops being a list of problems and becomes a list of things to do.

Rulesets are versioned and tested like code. Import a team's own human-authored review as ground truth, and the application scores against it. Change a ruleset and you get a diff on every benchmark title. A new version can't go live until a human accepts that diff and the system confirms it hasn't regressed on accuracy or recall.

It runs where your content is. As a managed service, or deployed into a customer's own AWS account for teams whose masters don't leave their perimeter.

How it works

Four ideas do most of the work.

We lean toward showing you more, not less. The two kinds of mistakes don't cost the same. If we flag something that turns out to be fine, a reviewer spends 15 seconds on it and moves on. If we miss something real, it ships, and there's nobody further down the line to catch it. So when a call is close, we'd rather put it in front of a person than settle it quietly ourselves.

That doesn't mean flagging everything. Every finding comes back with a severity and a band, so the serious ones sit at the top and the minor ones stay out of the way. Telling those apart is where most of our engineering goes.

The model proposes, the rules decide. Video models get things wrong in specific, repeatable ways. Once you can name a mistake, you can correct it every time it happens.

Here's one we see often. A ruleset lets context lower a grade: the scene is educational, the violence has visible consequences, the argument de-escalates. It never lets missing context raise one. But a model asked to explain its grade will happily write "the absence of educational framing warrants a high severity." That reads well and it's backwards: something that wasn't there has become a reason to grade harder. We catch it and step the grade back down.

What matters is what happens next. We don't overwrite the model's grade, we keep it. The reviewer sees the model proposed high; calibrated to strong, and which rule changed it. They can disagree with our correction, not just with the model.

Once the moments are graded, the title's rating is worked out from them by straight calculation. No model writes the verdict.

We measure every change before it ships. This is the part we'd have skipped if we'd stopped at a demo. Any team can build something that finds real violations in a week. Knowing whether yesterday's change made it better is the hard part and video models don't help, because running the same title twice moves the numbers.

So the measuring is built in. A team loads their own completed reviews as ground truth and we score against them. Edit a rule set and you get a title-by-title diff of what changed. A new version doesn't go live until a person has accepted that diff and the system has confirmed accuracy and recall didn't slip. And since a fresh run wouldn't reproduce exactly, we keep the run that was actually checked rather than quietly re-running it.

Where the human sits

The reviewer signs off. That isn't a disclaimer we've attached to an automated product, it's how the product is designed, for two practical reasons.

The first is that a compliance decision carries editorial and legal weight that belongs to the broadcaster. A system that renders the verdict without a name attached hasn't removed that risk, only moved it somewhere less visible.

The second is that reviewer decisions are the most useful data in the system. Ground truth from customers is sparse and selective: an unannotated moment isn't proof that flagging it was wrong. Reviewer decisions aren't ambiguous at all. A moment marked false positive is an over-flag. A moment a reviewer adds is a real miss. Seven violence moments pulled down a band by a human is a precise statement that those criteria are too strict, and in which direction.

So overrides are non-destructive. The model's grade sits beside the human's, permanently, in every export. A year later you can ask exactly where the two disagreed and use the answer to rewrite the criteria rather than to suppress the detection.

What it doesn't do

We'd rather say this here than in a pilot.

It doesn't clear content on its own. There's no auto-approve. Every finding is a candidate for review, and the review is the point.

It over-flags, and you'll reject some flags. That's the deliberate trade described above. We aim to make rejecting a flag cheap (evidence attached, one click, seconds) rather than to promise you'll never have to.

It's editorial quality control (QC), not technical QC. Content, context, framing and meaning. Not macroblocking, audio distortion or file conformance. Excellent tools already exist for that, and several of them are better placed to run alongside us than to be replaced by us.

It won't invent a single global rating. An aggregate verdict would have to be expressed on some one regulator's ladder, which is a rating no regulator issued. Where regimes disagree, a report shows both verdicts on the same moment.

Why a model company builds an application

A foundation model gives you a general capability. A compliance verdict is a specific outcome with a legal consequence attached.

Everything in between is the layer described at the top of this post, made concrete: calibration, regimes expressed as versioned data, an evaluation harness, an audit trail, and a review surface shaped around the way the errors actually fall. That work is real, it's where most of the value sits, and it doesn't happen by handing a customer an endpoint.

Compliance by TwelveLabs is available now, as a managed service or deployed into your own AWS account. Talk to our team to get a review running against your first title.