Legal disclaimers,
audited with zero guesswork.

A legal team can't
work in maybes.

A company's legal department needed every marketing page checked for the right disclaimers before it went live. This is not a place for a confidence score. A disclaimer is either legally required on a page or it is not, and getting it wrong carries real exposure. There was no room for error, no acceptable failure rate, and no appetite for an AI that answers one way today and another way tomorrow.

The catch: the audit itself is genuinely fiddly. Someone in legal had to open each page, study the imagery, read the copy, work out what the page was actually promoting, decide which disclaimers the rules demanded, and then write feedback back to the people who made it. Done by hand across a stream of pages, it was slow. Worse, it was inconsistent: two reviewers could reach two different verdicts on the same page, which is the last thing a legal function wants on record.

Great at ten pages.
Shaky at hundreds.

The first working version used a large language model. It read a screenshot of each page and returned the disclaimers it judged the rules required. On a handful of pages the results were genuinely good, good enough to make the whole job look solved.

Then we increased the number of records in each audit run, and the picture changed. At volume, the error count climbed to a level a legal function simply cannot carry: a disclaimer wrongly called, or quietly missed, with no way to see why the model decided what it did. Good on average is not good enough when every page is a compliance record. So we set out to make the audit deterministic, one moving part at a time: Amazon Rekognition for what is in the image, exact scraping for what the page says, and a similarity formula with fixed thresholds for the call itself.

Settling the final, no-LLM process took a lot of testing: we built an audit corpus of 150 records and ran more than 2,000 test passes over them, tightening one setting at a time. Then we put the two approaches head to head, the LLM against the deterministic workflow that replaced it, on 83 of those pages. The results were not what the first dashboard number suggested, and that comparison is a story of its own.

A skill first,
then scripts.

We didn't hand the legal team a black-box model and hope for the best. We hardened the workflow in three deliberate stages, taking the AI's judgment out of the live decision path a step at a time, until what shipped was ordinary, inspectable software.

Here's the path we took, from an AI following a recipe to software that runs the same way every time:

flowchart TD
  A["Stage 1: write the audit as a skill, explicit steps an LLM can follow"] --> B["Stage 2: run it against pages the lawyers already judged, tighten until they agree"]
  B --> C["Verify the process is correct on real pages, end to end"]
  C --> D["Stage 3: compile the steps into local scripts, deterministic software the company owns"]

Two checks on
every page.

Every page gets audited on two independent tracks, and both have to line up before the workflow signs off. Each track answers a different question, and neither one asks a language model to decide.

Put together, the two tracks answer the only thing legal cares about: given what this page shows and what it says, which disclaimers does the law require here?

No model in the
hot path.

Making the audit trustworthy meant removing the AI from the moment of decision. We got there with four pieces, and not one of them guesses.

Reading the image, in chunks

To validate what was in each image, we fed the base64-encoded image into code in multiple chunks and checked what was present piece by piece. That gave us high, repeatable detection results we could actually rely on, rather than a single opaque yes-or-no from a model we couldn't inspect.

Object detection with Amazon Rekognition

For detecting objects in imagery we moved to Amazon Rekognition, a dedicated computer-vision service. It is more deterministic than asking a language model what is in a picture, far easier to manage and cross-check, and at our volume it carried effectively no cost. That single change took a round from about $0.10 to close to zero.

Scraping the text with regex

The on-page text was the easy, fully deterministic half. We scraped it with dedicated scraping scripts built on regular expressions (regex), so extraction is exact and repeatable. The same page yields the same text every time, with no model in the loop and nothing left to interpretation.

Judging with a similarity score, not a vibe

The hard part was the judgment: does this combination of image and text require a disclaimer? Instead of asking an LLM to decide, we built a scoring formula based on similarity. We embedded the text several different ways and combined those embeddings into a single similarity score against the disclaimer rules. Fixed thresholds on that score turn a fuzzy call into a settled one.

The judgment then follows three explicit rules the legal team owns:

Because the bands are fixed numbers, the same page always lands in the same band. The lawyers can read the thresholds, challenge them, and change them, and the behavior changes with them, in the open.

flowchart TD
  A["Page in"] --> B["Amazon Rekognition detects objects in the image"]
  A --> C["Regex scraping extracts the on-page text"]
  B --> D["Embed and score similarity against the disclaimer rules"]
  C --> D
  D --> E{"Score vs fixed thresholds"}
  E -->|"above upper"| F["Disclaimer required, flag if missing"]
  E -->|"middle band"| G["Cannot be sure, route to a human"]
  E -->|"below lower"| H["Not required, no warning"]

Feedback the creators
can act on.

A page goes in, and the workflow returns legal feedback the page's creator can act on directly: which disclaimers are present, which are missing and legally required, and which cases still need a human to look at. No waiting on a reviewer's calendar, no two-reviewers-two-answers, and a clear record of why each call was made.

Because every step is deterministic software the company owns, the legal team runs the audit whenever they want and extends it themselves as the rules move: a new object to detect, a new rule to encode, a new threshold to set. The workflow doesn't drift, and nobody has to trust a model's mood on the day.

Zero guesswork,
at almost zero cost.

The legal team stopped grading pages by hand and stopped getting two answers for one page. Every verdict is repeatable, inspectable, and defensible, which is exactly what a compliance function needs on record. And because it's scripts they own, they run it on demand and adjust the rules themselves as regulations change, no vendor in the loop.

Curious how the deterministic workflow actually stacked up against the LLM it replaced? Read the full comparison, 83 pages side by side →

Common questions.