CreatorProof
The Content Integrity Compiler
CreatorProof turns one piece of creator content into publishable assets, then proves that the generated content still says what the creator actually meant.
GitHub:
https://github.com/louji2308/Crex
1. Inspiration
Creating a video is only part of the work.
After publishing or preparing a video, creators often use AI to turn it into:
- titles
- descriptions
- Shorts
- social posts
- captions
- pinned comments
- sponsor integrations
- thumbnails
- other platform-specific assets
The problem is that every transformation can change the original meaning.
A creator says:
“This laptop lasted the longest in my test.”
AI turns it into:
“This is the laptop with the best battery life.”
The second statement sounds more impressive.
It is also a different claim.
That is the problem CreatorProof is built around.
2. What CreatorProof Does
CreatorProof treats the original content as the source of truth.
It creates derivative assets, but every important generated claim is connected back to the evidence from the original source.
The system can identify:
- changed numbers
- exaggerated claims
- removed qualifiers
- scope changes
- certainty changes
- attribution loss
- unsupported claims
- missing sponsor requirements
- creator-intent violations
- platform-level publishing issues
Then it can:
detect → explain → repair → verify again → release
3. The Core Workflow
CREATOR SOURCE
│
▼
CONTENT UNDERSTANDING
│
▼
EVIDENCE GRAPH
│
┌───────────┼───────────┐
▼ ▼ ▼
Creator Intent Sponsor Audience
Contract Contract Context
│ │ │
└───────────┼───────────┘
▼
ASSET GENERATION
│
▼
INDEPENDENT VERIFICATION
│
┌──────┴──────┐
▼ ▼
PASS FAILURE
│ │
│ DIAGNOSE
│ │
│ REPAIR
│ │
│ RE-VERIFICATION
│ │
└──────┬──────┘
▼
RELEASE PASSPORT
│
▼
PUBLISH
4. How It Works
Step 1 — Add the source
The creator uploads a real video or provides an approved source.
CreatorProof stores the original source as the immutable reference.
Video
↓
Source Record
↓
Processing
Step 2 — Understand the content
CreatorProof analyzes the source and extracts structured information such as:
Topics
Entities
Claims
Numbers
Opinions
Recommendations
Qualifiers
Sponsor mentions
Timestamps
For example:
CLAIM
"Laptop C lasted longest in our test."
EVIDENCE
08:43 → 09:17
VALUE
11 hours 07 minutes
QUALIFIER
"in our test"
5. The Evidence Graph
The Evidence Graph is the foundation of CreatorProof.
Instead of storing only generated text, the system remembers where important information came from.
SOURCE VIDEO
│
▼
TRANSCRIPT SEGMENT
│
▼
SOURCE CLAIM
│
▼
EVIDENCE
│
▼
GENERATED CLAIM
│
▼
VERIFICATION RESULT
A generated statement can therefore be traced back to its original source.
6. Creator Intent
Not everything can be learned from the source itself.
The creator can define rules such as:
Tone:
Analytical
Audience:
Developers
Avoid:
Absolute claims
Misleading clickbait
Preserve:
Technical nuance
Test context
Uncertainty
CreatorProof uses these constraints during both generation and verification.
7. Sponsor Contract
Sponsor requirements can become machine-checkable constraints.
For example:
Sponsor name ✓
Disclosure ✓
Discount code ✓
Required URL ✓
Forbidden claims ✓
These requirements are checked against generated assets before release.
8. Real Content Generation
CreatorProof generates real derivative assets from the source.
Example:
Source Video
↓
YouTube Title
YouTube Description
Short Script
Social Post
Pinned Comment
Every generated asset is associated with the source information it depends on.
9. Integrity Verification
This is the core verification loop.
Generation and verification are deliberately separate.
GENERATED ASSET
│
┌────────────┼────────────┐
▼ ▼ ▼
Rule Engine Evidence Search Semantic Check
│ │ │
└────────────┼────────────┘
▼
FINDING ENGINE
│
┌───────┼───────┐
▼ ▼ ▼
PASS REVIEW BLOCK
The system uses deterministic checks wherever possible and semantic verification where meaning must be evaluated.
10. Example: Semantic Drift
Original source:
“Laptop C had the longest battery life in our test.”
Generated content:
“Laptop C has the best battery life.”
CreatorProof identifies the difference.
SOURCE
"longest battery life
in our test"
↓
GENERATED
"best battery life"
↓
FINDING
Scope inflation detected
The system explains why the claim changed.
11. Example: Numerical Drift
Source:
11 hours 07 minutes
Generated:
18 hours
CreatorProof performs deterministic comparison.
11h 07m
≠
18h
STATUS:
BLOCK
12. Example: Qualifier Loss
Source:
“For developers, Laptop C is my preferred choice.”
Generated:
“Laptop C is the best choice.”
CreatorProof detects that important context disappeared.
Qualifier removed:
"For developers"
Severity:
REVIEW
13. Example: Sponsor Failure
Suppose the sponsor contract requires:
Sponsor name
Disclosure
Discount code
The generated Short contains:
Sponsor name ✓
Disclosure ✗
Discount code ✓
CreatorProof returns:
BLOCKED
Reason:
Required sponsor disclosure missing.
The creator can repair the asset before release.
14. Repair
CreatorProof does not stop at identifying a problem.
It can propose a repair.
Before
This is the best laptop on the market.
Detected
Scope inflation
Suggested repair
This was the strongest laptop for developers in our test.
The repaired content is then verified again.
GENERATE
↓
VERIFY
↓
PROBLEM
↓
REPAIR
↓
VERIFY AGAIN
15. Re-Verification
A repair does not automatically make the content safe.
CreatorProof runs verification again.
BLOCK
↓
REPAIR
↓
REVERIFY
↓
PASS
This produces a complete audit trail.
16. Release Passport
When an asset is ready, CreatorProof generates a Release Passport.
Example:
CREATORPROOF RELEASE PASSPORT
Project
Budget Laptop Review
Assets
5
Claims
37
Evidence-linked claims
37 / 37
Unsupported claims
0
Sponsor violations
0
Creator-intent violations
0
Platform failures
0
Integrity Score
98 / 100
Status
READY
The passport summarizes the actual verification results.
17. Evidence Explorer
Any important generated claim can be inspected.
Generated claim
│
▼
Source claim
│
▼
Evidence
│
▼
Video timestamp
│
▼
Original content
For example:
Generated:
"Laptop C lasted longest."
Source evidence:
08:43 → 09:17
The creator can jump directly to the supporting evidence.
18. System Architecture
┌───────────────────────┐
│ Next.js UI │
│ TypeScript / Web │
└───────────┬───────────┘
│
▼
┌───────────────────────┐
│ Cloudflare Worker │
│ API Layer │
└──────┬──────┬─────────┘
│ │
┌───────────┘ └───────────────┐
▼ ▼
┌────────────┐ ┌────────────┐
│ D1 │ │ R2 │
│ Structured │ │ Media │
│ Data │ │ Storage │
└─────┬──────┘ └──────┬─────┘
│ │
└────────────────┬──────────────────┘
▼
┌───────────────────────┐
│ Cloudflare Workflows │
│ Durable Processing │
└───────────┬───────────┘
│
┌────────────┴────────────┐
▼ ▼
┌───────────────┐ ┌──────────────┐
│ Gemini Flash │ │ Local AI │
│ Primary AI │ │ Fallback │
└───────┬───────┘ └──────┬───────┘
│ │
└───────────┬────────────┘
▼
┌───────────────────────┐
│ Evidence Graph │
└───────────┬───────────┘
▼
┌───────────────────────┐
│ Integrity Engine │
│ │
│ Rules + Retrieval + │
│ Semantic Verification │
└───────────┬───────────┘
▼
┌───────────────────────┐
│ Repair Engine │
└───────────┬───────────┘
▼
┌───────────────────────┐
│ Release Passport │
└───────────────────────┘
19. Technology
Frontend
Next.js
TypeScript
Tailwind CSS
Zod
Application infrastructure
Cloudflare Workers
Cloudflare D1
Cloudflare R2
Cloudflare Workflows
AI
Gemini Flash
Ollama
Open-weight embedding model
Media
FFmpeg
faster-whisper / WhisperX fallback
Search
Vectorize / approved vector layer
Provenance
C2PA
Testing
Vitest
pytest
Playwright
20. Why the Architecture Is Designed This Way
CreatorProof deliberately separates responsibilities.
AI
↓
understands and generates
Rules
↓
perform deterministic validation
Evidence
↓
grounds generated claims
Verification
↓
decides whether output is acceptable
Repair
↓
fixes detected problems
Passport
↓
records the final release state
The system does not ask an AI model to simply generate an answer and then trust itself.
21. Reliability Model
The system follows:
GENERATE
↓
VALIDATE
↓
GROUND
↓
VERIFY
↓
DECIDE
AI outputs are treated as untrusted until they pass the appropriate validation.
Deterministic checks are performed by code.
Semantic checks use evidence-grounded AI reasoning.
Fallbacks are explicitly reported rather than silently presented as primary processing.
22. Real Example
Input
A 12-minute laptop review.
The creator uploads it and defines:
Audience:
Developers
Tone:
Analytical
Avoid:
Absolute claims
Sponsor:
TechBrand
Required:
Disclosure + discount code
CreatorProof produces
1 YouTube package
2 Shorts
1 pinned comment
1 social post
During verification
It detects:
1 scope drift
1 missing sponsor disclosure
1 numerical mismatch
CreatorProof repairs them.
Final result
All critical findings resolved.
Release status:
READY
23. What Makes the Output Verifiable
For important generated content, CreatorProof can answer:
What was generated?
Where did it come from?
Which source claim supports it?
Which timestamp supports that claim?
Which creator rule applies?
Which sponsor requirement applies?
Which verification run approved it?
Was it repaired?
What changed?
This creates an explicit chain from:
SOURCE
→ EVIDENCE
→ GENERATION
→ VERIFICATION
→ RELEASE
24. What We Built
CreatorProof is not just a content generator.
It is a system for:
UNDERSTANDING
+
GENERATION
+
PROVENANCE
+
VERIFICATION
+
REPAIR
+
RELEASE
The creator remains in control of the final decision.
25. Technical Highlights
Evidence-first architecture
Important generated content is linked to source evidence.
Deterministic verification
Numbers, timestamps, required phrases and platform constraints are checked with deterministic rules where possible.
Semantic verification
Meaning changes such as scope inflation, qualifier removal and certainty drift are evaluated separately.
Contract-based generation
Creator preferences and sponsor obligations become explicit constraints.
Repair loop
Problems can be corrected and verified again.
Reproducible evaluation
Adversarial test cases are maintained for common content-drift failures.
Real asynchronous processing
Long-running content processing uses durable workflow execution rather than blocking a request.
26. Repository
GitHub:
https://github.com/louji2308/Crex
The repository contains:
apps/
packages/
processing/
tests/
benchmarks/
docs/
The project also documents its architecture, verification model, provenance model, benchmarks and implementation decisions.
27. Demo
The demo focuses on one complete real workflow:
Upload
↓
Understand
↓
Generate
↓
Detect a real integrity problem
↓
Show the exact source evidence
↓
Repair
↓
Verify again
↓
Release Passport
The objective is to show the system doing real work, not merely displaying a static interface.
28. Built During the Hackathon
CreatorProof was implemented during the hackathon period in accordance with the challenge requirements.
The implementation uses real services, real processing and real verification paths.
Where a fallback is used, the interface explicitly identifies it as a fallback.
29. Future Direction
The current core system is intentionally focused.
Future extensions include:
cross-platform publishing
deeper audience intelligence
performance-based learning
creator-specific historical modeling
additional provenance integrations
agency/client workflows
larger content portfolios
These are extensions of the same core idea:
Generated creator content should remain traceable, verifiable and faithful to the source.
30. Final
CreatorProof
Generate. Prove. Repair. Release.
AI should make content creation faster without making the creator lose control of what the content actually says.
Built With
- c2pa
- cloudflare
- ffmpeg
- next.js
- nvidia
- openrouter
- zod
Log in or sign up for Devpost to join the conversation.