Percept

Video Optimization Platform with Pika
Watch the predicted response frame by frame. Percept shows where attention rises, where it falls, and what the next version should change.
From prompt to model-ready ad plan: Percept researches the brand, pulls context from Redis, and uses custom Pika MCP skills to create vids.
Human Benchmark Classifications

Inspiration

Percept started with a small family business.

Someone close to Dean was trying to grow their restaurant with video ads. From the outside, the process looked simple: make a short ad, choose a budget, launch it, and wait.

But from the inside, it felt like guessing in the dark.

The budget was tight. Every ad had to count. A failed campaign meant less room for the next idea, less confidence in the next launch, and another week spent wondering what went wrong.

When the results finally came back, they were blunt but incomplete. Low clicks. Weak watch time. Poor conversion. The dashboard could say the ad failed, but it could not explain the moment people stopped caring.

That gap became our project.

Small businesses are not short on effort. They are short on signal. They need a way to understand which video is worth showing before the budget is already gone.

So we built Percept: a system that researches, generates, scores, and improves video ads before they go live.

What it does

Percept is a self-improving video ad system.

A user enters a product, audience, brand, and goal. For example:

Make a 15-second TikTok ad for a high-protein iced coffee aimed at college students before class.

Percept then runs a loop:

Research the product, audience, and short-form ad patterns.
Store that research and iteration history in Redis.
Create a structured creative plan.
Generate a short-form video using custom skills from the Pika MCP.
Predict attention using TRIBE v2.
Score the video based on the predicted response over time.
Rewrite one part of the creative plan and generate again.

The user does not just get one AI-generated video. They get a ranked set of versions, an attention score for each one, and a clear reason for what changed.

For example, Percept might find that version one waits too long to show the product. The next version moves the product into the opening shot, keeps the rest of the structure mostly fixed, and runs the scoring loop again.

That is the core idea: not just generation, but generation with feedback.

How we built it

Redis and Pika are the backbone of Percept.

Redis gives Percept memory. We use Redis for vector retrieval, research storage, caching, and iteration history. When Percept researches a product or audience, that context is saved. When it generates a video, the score is saved. When it rewrites the next version, the change is saved too.

That lets Percept track a real creative path:

what research shaped the first idea
what video was generated
how that video scored
what changed in the next version
whether the score improved or dropped

Without Redis, each generation would be isolated. With Redis, every attempt becomes part of the loop.

Pika gives Percept production. We use custom skills from the Pika MCP to turn creative plans into real short-form videos. The plan includes the hook, visual beats, product timing, pacing, emotional angle, and call to action. Pika lets us move from text strategy to an actual video that can be scored and improved.

TRIBE v2 gives Percept a prediction layer. TRIBE v2 takes video, audio, and language and predicts neural response over time. It does not output “good ad” or “bad ad.” It outputs a time series of predicted brain activity.

So we built the scoring layer ourselves.

Our score uses three signals:

Response strength — how strong the predicted response is overall.
Peak response — where the strongest moment happens.
Temporal drop-off — where the response fades or flattens.

This matters because two videos can have the same average score but feel completely different. One might start strong and die in the middle. Another might build steadily and hold attention until the end. Percept looks at the shape of the response, not just one number.

Then an LLM agent receives:

the current creative plan
the TRIBE v2 score breakdown
the prior version history from Redis
the allowed creative levers it can change

To keep the loop interpretable, the agent changes one main lever at a time: hook, product timing, pacing, visual motion, or call to action. That way, when the score moves, we can understand what likely caused it.

Please check out our repo for more details on the Redis memory layer, Pika MCP pipeline, TRIBE v2 scoring code, and generation loop.

Challenges we ran into

The hardest challenge was not making a video. It was knowing what to do after the video was made.

Most AI video tools stop at generation. Percept had to evaluate the output and decide what to change next.

TRIBE v2 made that possible, but it was not plug-and-play. The model gives predicted neural activity, not marketing advice. We had to build the layer that turns a brain-response time series into a practical attention score.

The second challenge was speed. A loop only matters if it can run more than once. Video generation takes time, and TRIBE v2 is heavy. Redis helped us keep the system usable by caching expensive outputs, storing research, and carrying memory across iterations.

The third challenge was avoiding fake improvement. Early versions changed too many things at once. If the score went up, we could not tell why. If it dropped, we did not know what broke.

So we constrained each rewrite to one main creative lever. Instead of changing the entire ad, Percept makes one targeted move, scores again, and stores the result.

That made the system easier to inspect, easier to debug, and more credible as a creative tool.

Accomplishments that we're proud of

We built a working loop that closes.

Percept researches, creates, predicts, remembers, and tries again. It does not just produce more content. It gives each version a measurable signal and uses that signal to guide the next attempt.

We are proud that Redis and Pika became core to the product, not side integrations. Redis is the memory and retrieval layer. Pika is the production layer. Together, they make the loop possible.

We are also proud that we got TRIBE v2 running as part of an actual creative workflow. The model’s output is complex, so turning it into a score that can guide iteration was one of the most technically important parts of the project.

The moment the product clicked was when one targeted change moved the result:

The first ad opened slowly. Percept moved the product earlier. The next version scored higher.

That does not guarantee the ad would win in the market. But it does prove the loop works: generate a version, measure a signal, make a controlled change, and run again.

What we learned

We learned that generation is only half the problem.

AI can already make more videos than any team can reasonably review. The harder question is which version deserves attention, time, and budget.

We also learned that attention has a shape. A video can start strong and fade. It can reveal the product too late. It can look polished and still feel flat.

That is why Percept does not only return a score. It tracks how attention moves through the video and uses that pattern to decide what to change next.

We also learned to be careful about what the score means. TRIBE v2 gives us a predicted attention proxy, not guaranteed campaign performance. Percept uses that signal as an early creative guide, and the next step is validating it against human preference and real ad metrics.

What's next for Percept

Next, we want to make the attention curve visible directly on the video. A user should be able to see where attention rises, where it falls, and what changed between versions.

We also want more direct human feedback. During the hackathon, we had dozens of friends try Percept, compare generated versions, and tell us which videos felt more engaging. That gave us an early sanity check, but we want to scale it into a real feedback system: more users, more comparisons, and a stronger link between Percept’s attention score and what people actually choose to watch.

Longer term, we want to connect that feedback to real campaign metrics like watch time, click-through rate, and conversion. TRIBE v2 gives us an early predicted attention signal, but the goal is to keep improving that signal with human preference and real-world outcomes.

We are starting with short-form ads because the pain is immediate. A small business should not have to spend its budget just to find out that a video did not work.

But the same loop can apply to product demos, launch videos, trailers, thumbnails, pitch videos, and education.

Generative AI is making it effortless to create more content. That will not be the advantage for long.

The advantage will be knowing what is worth showing.

Percept is built for that future: creative generation with memory, production, feedback, and judgment.