Hook Rate Memory: How a Context Engine Tracks and Improves Hooks Over Time

Hook rate as a metric versus hook memory as infrastructure

Hook rate — the percentage of viewers who watch past the first 3 seconds of a video ad — is one of the most actionable creative metrics in performance marketing. It measures whether the opening frame and copy captured attention before the audience scrolled past. A hook rate above 30% is generally considered strong; below 20% signals that the hook is not working.

But hook rate as a metric answers a backward-looking question: how did this hook perform? What most creative workflows lack is the forward-looking infrastructure: given that I need to write a new hook today, what does the full history of every hook this brand has tested tell me about what to write?

That is hook memory. Not a column in a spreadsheet. A queryable, time-decayed, semantically indexed record of every hook this brand has tested, with hook rate and completion rate attached, so that the next brief can start from evidence about what the audience stops for — not from whatever the strategist remembers from last quarter.

What hook memory requires technically

Building hook memory requires three things: a vector embedding of each hook (so semantically similar hooks can be retrieved together), performance metadata attached to each embedding (hook rate, 3-second view rate, completion rate, spend), and a temporal decay model that weights recent hooks more heavily than old ones without discarding the older ones entirely.

Feather DB provides all three in the Adaptive Memory layer. Each hook is stored as a vector in the HNSW index with metadata attributes attached. The half-life decay model configured at query time weights recent high-performing hooks most heavily, while still surfacing exceptional performers from further back if they are semantically relevant to the current brief.

import feather_db as fdb
from feather_db import ScoringConfig, MetaRecord

db = fdb.DB.open("brand_hook_memory.feather", dim=768)

def ingest_hook(hook: dict, embedder):
    vec = embedder.embed(hook["text"])

    meta = MetaRecord()
    meta.set_attribute("hook_rate",         hook["hook_rate"])       # 0.0–1.0
    meta.set_attribute("completion_rate",   hook["completion_rate"]) # 0.0–1.0
    meta.set_attribute("three_sec_rate",    hook["three_sec_rate"])  # 0.0–1.0
    meta.set_attribute("spend",             hook["spend"])
    meta.set_attribute("format",            hook["format"])          # ugc / motion / static
    meta.set_attribute("audience_segment", hook["segment"])
    # Importance: spend-weighted, scaled
    meta.set_attribute("importance", min(1.0, hook["spend"] / 30_000))

    db.add(
        id=hook["id"],
        vec=vec,
        text=hook["text"],
        namespace="brand::hooks",
        meta=meta
    )

def get_hook_context(brief_params: str, segment: str, embedder) -> dict:
    q = embedder.embed(brief_params)

    return {
        "top_hooks": db.search(
            q, k=8, namespace="brand::hooks",
            scoring=ScoringConfig(half_life=120.0, weight=0.35, min=0.0),
            filters={"audience_segment": segment}
        ),
        "format_leaders": db.search(
            q, k=4, namespace="brand::hooks",
            scoring=ScoringConfig(half_life=90.0, weight=0.45, min=0.0),
            filters={"min_hook_rate": 0.30}
        ),
    }

At 0.19ms p50 ANN latency, a two-namespace hook context query returns in under 1ms. The retrieval surfaces the hooks most likely to perform well given the current brief — not the hooks that performed best overall, but the hooks that are semantically closest to the current brief parameters and have the strongest recent performance record for the target audience segment.

Hook patterns that only memory can surface

Individual hook rate data tells you whether a specific hook worked. Accumulated hook memory tells you patterns: which opening structures consistently produce hook rates above 30% for this brand, which emotional triggers reliably capture the 25–34 female segment, which claim formats (stat-led, question-led, problem-statement-led) have the strongest completion rates in this category.

These patterns are not visible in a dashboard view of individual campaigns. They emerge from querying across the full history of the hook index. A stat-led hook query might surface: 12 of the 14 stat-led hooks in the index with hook rates above 25% opened with a specific number format. That is a pattern specific to this brand and audience, not visible in industry benchmarks, and not reconstructable from memory — it requires the index.

Hook memory and the brief generation loop

Hawky.ai, built on Feather DB, generates 1,000+ creatives per month for brands including Bombay Shaving Co. and Razorpay. Hook quality at that volume cannot be maintained through individual creative judgment — the context engine is the consistency layer. Every hook brief pulls from the accumulated hook memory for that brand, ensuring that hook directions are informed by what has actually worked for this specific audience rather than general best practices.

The 20% CTR uplift that Univest saw in the first week of deployment reflects what happens when hook briefs start from evidence. The first-week gain is the immediate effect of better-evidenced hook selection. The sustained 27% CPL reduction seen by Hiveminds reflects the compounding effect of each campaign cycle enriching the hook memory for the next one.

Linking hook performance to creative outcomes

Hook rate is a leading indicator, not a lagging one. A high hook rate predicts that the creative will have more opportunity to deliver its full message — but only if the rest of the creative delivers on what the hook promised. The context engine can encode this relationship explicitly, linking hook nodes to full creative nodes and downstream to campaign ROAS outcomes.

def link_hook_to_outcome(hook_id: str, creative_id: str, campaign_id: str, outcome: dict):
    # Link hook to the creative it appeared in
    db.link(from_id=hook_id, to_id=creative_id,
            rel_type="appeared_in", weight=1.0)
    # Link creative to campaign outcome
    db.link(from_id=creative_id, to_id=campaign_id,
            rel_type="drove",
            weight=min(1.0, outcome["roas"] / 5.0))

def get_hook_roas_chain(hook_id: str) -> list:
    # Full chain: hook -> creative -> campaign ROAS
    return db.context_chain(
        start_id=hook_id,
        rel_types=["appeared_in", "drove"],
        direction="outgoing",
        max_depth=2
    )

The chain traversal answers the question that hook rate alone cannot: does a hook that generates a 35% hook rate actually convert? For this brand, in this category, the answer lives in the chain — not in the hook rate metric in isolation.

FAQ

What hook rate threshold should be used when filtering the context engine retrieval?

Use the brand's own historical distribution, not industry averages. If 60% of this brand's hooks have hook rates between 18–28%, filtering for 25%+ will surface the upper half of the brand's own track record — which is the relevant baseline. Industry averages ("30% is good") may not apply to a specific brand's audience, creative style, or category competitive environment. Build the filter from the actual distribution in the index.

Can the context engine distinguish hook performance by ad format?

Yes. Format is stored as a metadata attribute per hook record. Retrievals can be filtered or weighted by format: UGC hooks tend to outperform polished motion hooks for specific audience segments; static hooks have different hook-rate baselines than video. The metadata layer makes format-specific analysis explicit without requiring separate indexes per format.

How does hook memory handle hooks that performed well once but in atypical conditions?

Through importance weighting. A hook that ran during a major sale event at unusually high reach, and achieved a 42% hook rate in that context, gets an importance weight that reflects its spend level but its context metadata flags the sale event condition. At retrieval time, if the brief is not for a sale event, the contextual mismatch (if encoded in the embedding) will reduce its semantic relevance score. The importance weight and semantic relevance multiply to produce the final retrieval rank.

How many hooks are needed before hook memory produces reliable brief guidance?

50 hooks with hook rate data is the minimum for meaningful pattern detection. At 150+ hooks, the index contains enough variation to surface reliable insights about what structures work for which segments. For brands generating 1,000+ creatives per month, the index reaches useful density within the first 2–3 months of operation. Bootstrap with historical data if available — even old campaign data with hook-level metrics is better than starting from scratch.

Can hook memory be used to audit hooks before they go live?

Yes. Pre-launch hook auditing is one of the highest-value retrieval patterns: embed the draft hook, query the index for similar precedents, and surface what those precedents produced. If the 5 most similar hooks in the index all have hook rates below 20%, the draft hook is in semantically familiar but historically weak territory. The audit does not require any model evaluation of the hook — just a semantic similarity retrieval against the performance-labeled index.