How a Context Engine Detects Creative Fatigue Before It Kills Your ROAS

What dashboards see versus what memory sees

Every performance marketing team has a version of the same story: a creative runs well for three weeks, the team keeps budget behind it, and by week five ROAS has dropped 22% before anyone notices. The post-mortem always reveals the same thing — the signals were there. Frequency ticked up. CTR started sliding. But the dashboard showed numbers, not patterns, and no one was watching close enough.

A context engine does not watch metrics. It watches patterns in accumulated memory. The distinction matters because patterns precede metric deterioration by a measurable margin. By the time frequency and CTR move enough to trigger a dashboard alert, the audience has already been oversaturated. The ROAS drop is the consequence, not the signal.

Early detection requires a system that stores what has happened before — how long previous creatives of this type ran before fatigue appeared, what early-cycle engagement patterns preceded later fatigue, how audience segment behavior shifted in the days before performance degraded. That is institutional memory, not analytics. And it requires infrastructure built to hold it.

The anatomy of a fatigue pattern in memory

Creative fatigue is not a single event. It is a trajectory: a sequence of micro-signals that, taken together, predict saturation before metrics confirm it. The signals include CTR velocity (how fast CTR is decelerating relative to the creative's own baseline), impression share per audience segment, creative similarity clustering (whether recent high-spend creatives are converging toward the same semantic space), and historical precedent (how long similar creatives for this brand lasted before fatigue appeared).

A context engine stores all of these signals, not as flat rows in a table, but as time-decayed vectors in an indexed memory layer. Each creative in the index carries its own temporal fingerprint — when it was launched, how long it ran, what its fatigue signature looked like. New creatives can be semantically matched against this history to retrieve the closest precedents.

The Feather DB adaptive memory layer uses a configurable half-life decay model. A creative flagged as fatigued gets its importance weight decayed; a creative in its peak performance window gets boosted recall stickiness. At 97.2% recall@10 on the HNSW index, the retrieval is precise enough to surface true precedents rather than superficially similar ones.

How the detection works in code

import feather_db as fdb
from feather_db import ScoringConfig
from datetime import datetime, timedelta

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

def detect_fatigue_risk(current_creative: dict, embedder) -> dict:
    q = embedder.embed(current_creative["copy"])

    # Retrieve semantically similar creatives from history
    similar = db.search(
        q, k=8, namespace="brand::creatives",
        scoring=ScoringConfig(half_life=180.0, weight=0.4, min=0.0)
    )

    # Check for semantic clustering — if top 3 recent creatives
    # are all semantically close, saturation is building
    recent_vecs = db.search(
        q, k=3, namespace="brand::active_creatives",
        scoring=ScoringConfig(half_life=14.0, weight=0.8, min=0.0)
    )

    fatigued_precedents = [
        r for r in similar
        if r.meta.get("fatigue_day") and r.meta["fatigue_day"] < 21
    ]

    avg_fatigue_day = (
        sum(r.meta["fatigue_day"] for r in fatigued_precedents) / len(fatigued_precedents)
        if fatigued_precedents else None
    )

    days_live = (datetime.now() - current_creative["launched_at"]).days

    return {
        "days_live": days_live,
        "avg_historical_fatigue_day": avg_fatigue_day,
        "days_to_predicted_fatigue": (
            round(avg_fatigue_day - days_live, 1) if avg_fatigue_day else None
        ),
        "semantic_cluster_risk": len(recent_vecs) >= 3,
        "similar_precedents": len(fatigued_precedents),
    }

At 0.19ms p50 ANN latency, this check adds under 2ms per creative evaluation. The entire detection logic runs client-side — no external API call, no cloud dependency. The .feather file ships with the inference code.

What early detection changes operationally

The practical effect of detecting fatigue 5–10 days before dashboard metrics confirm it is that creative rotation can happen proactively rather than reactively. Instead of cutting a creative after ROAS has already declined, teams brief the replacement while the current creative is still performing — so there is no coverage gap.

Hawky.ai, which runs on Feather DB, reports that teams using context-aware creative management produce 1,000+ creatives per month with CPA declining 15% over a sustained period. Part of that gain comes from never running fatigued creatives past their effective window. The memory layer knows when the window closes, for each brand, in each category, before the campaign manager does.

The cost of not having this layer

Without memory, the detection ceiling is what the dashboard surfaces. With memory, the detection ceiling is what patterns in history predict. The difference in response time — 5 to 10 days — is enough to prevent one full ROAS dip per creative cycle. For a brand spending $200K/month on paid social, one prevented dip per cycle at 20% ROAS degradation is $40K preserved per month. The infrastructure cost of running Feather DB is negligible by comparison: $2.40 for a full benchmark evaluation run against 50+ memory queries.

LongMemEval scores tell the same story at the benchmark level: Feather DB scores 0.693 versus 0.640 for GPT-4o on long-horizon memory tasks. Fatigue pattern detection is precisely the kind of long-horizon reasoning that the benchmark tests — connecting signals across weeks of campaign history to predict near-term outcomes.

FAQ

What data does a context engine need to detect creative fatigue?

At minimum: creative copy or visual embeddings, launch date, daily CTR, and spend. The more historical campaigns in the index, the more precise the fatigue prediction. Even 20–30 past creatives with outcome data is enough to start surfacing meaningful precedents. The prediction improves continuously as more campaigns are ingested.

How is context engine fatigue detection different from frequency capping?

Frequency capping is a constraint applied to individual users. Context engine fatigue detection is a pattern-matching operation applied to the creative itself, across all audiences. It catches semantic saturation — when a brand's active creatives are converging toward the same message territory — which frequency capping does not see at all.

Can the context engine detect fatigue across different ad formats?

Yes. Feather DB indexes any text or embedding — copy, visual descriptions, hook transcripts. A context chain can link a video hook to a static version of the same message, so the engine knows the audience has already been exposed to the core idea regardless of format. The db.context_chain() traversal makes cross-format relationship tracking explicit.

How early can fatigue be predicted reliably?

With sufficient campaign history, prediction windows of 5–10 days before metric confirmation are achievable. The prediction is probabilistic — it says "creatives in this semantic cluster, for this brand, typically fatigued at day 18" — not deterministic. The confidence increases with more precedents in the index. Early in a brand's history on the platform, predictions are wider-interval; they tighten with accumulated data.

Does the context engine replace the need to monitor campaign dashboards?

No. It augments monitoring by adding a predictive layer that surfaces risk before it appears in metrics. Teams still need to act on actual performance data. The value is in the lead time — the ability to prepare creative rotation before it becomes urgent, rather than scrambling after ROAS has already dropped.