Litmus

Nothing ships until it proves itself...

Comment

Inspiration

A creative agency working on an important campaign for a large client.

The designer uses one AI tool to create an image, another tool to improve it, and a third tool to turn it into a video. The campaign looks great and is almost ready to go live.

Then the client asks a few simple questions:

Which AI model was used?

Was that provider approved in our contract?

Was the required disclosure added?

Who reviewed the final version?

Can you prove that this file has not been changed?

Suddenly, the team has to search through emails, chat messages, spreadsheets, folders, and old project files. Even after all that work, they may still not have a complete answer.

This is the problem that inspired Litmus.

Generative AI has made content creation much faster, but the compliance process has not kept up. Most teams only think about evidence after the content has already been created.

We wanted to build something that checks compliance before the asset reaches the client.

That is why Litmus is built around one simple idea:

Nothing ships until it proves itself.

Litmus checks the complete history of an AI-generated asset, finds problems before delivery, guides the team through remediation, and protects the final evidence for future audits.

What it does

Litmus is a compliance operations platform for AI-generated media.

It follows an asset from the moment it is created until the moment it is delivered.

For every asset, Litmus records information such as:

  • the AI provider;
  • the model;
  • generation parameters;
  • prompts or protected prompt commitments;
  • timestamps;
  • file hashes;
  • parent and child versions;
  • human approvals;
  • disclosure requirements;
  • client contract rules.

Litmus then checks the complete history of the asset.

For example, imagine that the first version of a campaign image was created using a provider that the client did not approve.

The image may look perfect, but Litmus checks the evidence and finds three problems:

  • the provider is not allowed;
  • the required disclosure is missing;
  • no human approval has been recorded.

Litmus blocks the asset before delivery and clearly explains each reason.

The team can then create a corrected version using an approved provider, add the required disclosure, and record a human review.

Litmus keeps the original version in the history and connects the corrected version to it.

The updated asset is checked again by Litmus's deterministic policy engine.

The result can be:

  • PASS
  • BLOCK
  • NEEDS_REVIEW

An AI model never makes the final compliance decision.

If the asset passes, Litmus:

  1. creates a signed compliance decision;
  2. generates an Evidence Passport;
  3. stores the evidence in Backblaze B2;
  4. protects it with Object Lock;
  5. connects delivery to the exact approved file version;
  6. creates a complete audit trail.

An auditor can then ask questions such as:

  • Why was this asset approved?
  • Which model generated it?
  • Who reviewed it?
  • What changed between the first and second version?
  • Which contract rule was applied?
  • Can this version still be delivered?

Litmus answers using evidence and citations from the recorded workflow.

How we built it

We built Litmus as a secure backend-first compliance platform.

Genblaze manages the AI-media workflow and provenance history.

A typical Litmus workflow can include:

  1. preparing the campaign brief;
  2. generating an image or storyboard;
  3. creating a video or motion asset;
  4. adding the required disclosure;
  5. generating a preview and thumbnail;
  6. embedding provenance into the media;
  7. verifying the manifest;
  8. storing the final asset and evidence in Backblaze B2.

For each step, Litmus records:

  • provider and model;
  • generation parameters;
  • execution mode;
  • timestamps;
  • output hashes;
  • retries;
  • provider fallbacks;
  • parent and child run relationships.

The provider system is configuration-driven.

This means we can add or switch API providers using environment settings without changing the main compliance workflow.

Litmus supports:

  • NVIDIA NIM for live generation and AI capabilities;
  • GMI Cloud as an optional media provider;
  • Google Gemini for non-authoritative tasks such as contract extraction and audit query planning;
  • a local deterministic provider for development and testing;
  • verified cached media for a stable Demo Safe mode.

Every operation is clearly marked as:

  • LIVE
  • CACHED_VERIFIED
  • LOCAL_SIMULATION
  • UNAVAILABLE
  • FAILED

Litmus never presents cached or locally generated media as a live provider result.

Backblaze B2 is used as the storage and evidence backbone.

Litmus separates storage into:

  • temporary drafts;
  • final client assets;
  • immutable compliance evidence;
  • public redacted Evidence Passports.

The evidence package can include:

  • the Genblaze manifest;
  • the complete version history;
  • approved contract controls;
  • the policy bundle;
  • the signed compliance decision;
  • the human approval;
  • provider execution receipts;
  • file hashes;
  • storage receipts;
  • the Evidence Passport;
  • delivery records.

After uploading evidence to B2, Litmus retrieves the exact object version again and verifies its SHA-256 hash.

It also checks the Object Lock mode and retention date before claiming that the evidence is protected.

The final compliance verdict comes from a deterministic policy engine.

AI can help understand contracts, summarize changes, explain findings, and suggest remediation. It cannot approve an asset or change the final result.

Every passing decision is hashed and signed using Ed25519.

Before delivery, Litmus checks:

  • the latest decision;
  • the digital signature;
  • the policy version;
  • the asset hash;
  • the evidence package;
  • the complete asset history;
  • the exact storage version;
  • the delivery destination;
  • the authorization expiry time.

Only the exact approved version can be delivered.

Challenges we ran into

One of our biggest challenges was deciding where AI should be trusted.

AI is useful for understanding contracts and explaining complex information. However, using an AI model to decide whether an asset is compliant would make the result difficult to reproduce and defend.

We solved this by separating intelligence from authority.

AI can suggest and explain.

The deterministic policy engine decides.

Another challenge was proving that the evidence itself had not been changed.

Storing a manifest next to a file was not enough. We needed to verify the asset bytes, the embedded provenance, the external manifest, the version history, the policy version, the signed decision, and the storage version together.

We also had to plan for provider failures.

Free and external APIs can be rate-limited, unavailable, or missing credentials. Litmus uses clear execution modes and safe provider fallback rules.

If a provider fails, Litmus records the failure and either chooses an allowed fallback or stops honestly.

It never silently switches to a provider that the client contract does not allow.

Multi-tenant security was another major challenge.

Compliance evidence may include private contracts, prompts, campaign details, approvals, and client information.

We added tenant and client isolation across the API, storage, evidence, audit, and delivery layers.

Finally, we had to connect many complex features into one clear product story.

Instead of showing twelve unrelated agents, Litmus focuses on one workflow:

Detect the problem, block delivery, fix the asset, prove compliance, protect the evidence, and deliver safely.

Accomplishments that we're proud of

We are proud that Litmus does not ask judges, clients, or auditors to trust an AI-generated compliance answer.

The final decision is deterministic, signed, and independently verifiable.

We built a complete working flow where:

  • a risky asset is detected;
  • delivery is blocked;
  • exact policy failures are shown;
  • a corrected child version is created;
  • the full version history is verified;
  • the updated asset passes;
  • the decision is digitally signed;
  • the evidence is protected;
  • delivery is connected to the exact approved version;
  • audit questions are answered with citations.

We are also proud of the security work behind Litmus.

The system can detect:

  • modified asset files;
  • altered manifests;
  • broken version history;
  • changed policy files;
  • invalid signatures;
  • modified evidence;
  • stale delivery tokens;
  • incorrect storage versions;
  • cross-tenant access attempts;
  • false Object Lock claims.

Litmus also includes twelve bounded operational agents:

  1. Lineage Intelligence Agent
  2. Deterministic Compliance Gate
  3. Contract Intelligence Agent
  4. Risk Preflight Agent
  5. Replay Agent
  6. Policy Change Agent
  7. Disclosure Agent
  8. Evidence Agent
  9. Vendor Intelligence Agent
  10. Audit Readiness Agent
  11. Client Portal Agent
  12. Conversational Auditor

Each agent has a clear responsibility and controlled permissions.

They work together as one compliance system instead of acting like separate chatbots.

What we learned

The biggest thing we learned is that provenance alone is not enough.

Knowing how an asset was created is useful, but businesses need action.

They need risky content to be stopped before it reaches the client.

They need clear reasons, guided remediation, protected evidence, and safe delivery.

We also learned that AI compliance needs a clear trust boundary.

AI is excellent at understanding unstructured information. It can read a contract, explain a rule, and help an auditor search through evidence.

However, important compliance decisions should be deterministic, versioned, signed, and reproducible.

We also learned that storage can be part of the compliance workflow.

Backblaze B2 is not only a place where Litmus saves files.

Its object versions, hash verification, retention controls, and Object Lock protection help prove that the evidence has not been quietly changed or deleted.

Another important lesson was the value of honest fallback behavior.

A system should always say whether an operation was live, cached, local, unavailable, or failed.

A reliable demo should not depend on hiding API failures.

Finally, we learned that a strong multi-agent system is not a collection of AI personalities.

Each agent needs a narrow responsibility, typed inputs and outputs, controlled permissions, persistent state, and measurable results.

What's next for Litmus

Our next goal is to turn Litmus into a complete AI Compliance Operations platform for agencies, brands, legal teams, auditors, and insurers.

We plan to improve contract intelligence so teams can upload PDF and DOCX agreements.

Litmus will extract possible requirements, show the exact source text, and send every rule through a human approval workflow before it becomes active.

We also plan to add continuous policy and vendor monitoring.

Litmus will track changes in:

  • AI regulations;
  • provider terms;
  • commercial-use policies;
  • model availability;
  • privacy policies;
  • data-retention rules;
  • watermark requirements.

When something changes, Litmus will identify:

  • affected clients;
  • affected policies;
  • affected assets;
  • assets that need another review;
  • delivery permissions that may need to be cancelled.

The Conversational Auditor will also become more powerful.

Auditors will be able to ask questions across multiple campaigns, providers, models, dates, approvals, and policy versions.

They will also be able to export complete offline audit packages with hashes, signatures, manifests, approvals, and verification scripts.

Future additions include:

  • C2PA Content Credentials;
  • more Genblaze providers;
  • image, video, audio, and voice compliance;
  • Slack and Microsoft Teams integrations;
  • digital asset management integrations;
  • enterprise identity and SSO;
  • managed signing keys;
  • regional storage controls;
  • compliance packs for different countries;
  • insurer-facing compliance scoring APIs.

Our long-term vision is simple.

AI can create the content.

Litmus makes sure it is safe to deliver.

Built With

Share this project:

Updates