DEV Community: gobuy.ai

The Shape of a Review History: Trajectory Analysis for Trust Scoring

gobuy.ai — Wed, 14 Oct 2026 08:31:21 +0000

When we started scoring products at GoBuy, the obvious first move was treating the review history as a pile: aggregate the ratings, compute a Wilson confidence interval, ship a score. That works fine for a book with 400 reviews accumulated over six years at a steady 4.2 stars. It fails catastrophically for the products fraudsters care about — the ones whose histories look fine in aggregate but wrong in shape.

This post is about the second layer of our pipeline: trajectory analysis. We stopped asking "what is the average rating?" and started asking "how did this product get here?" Because in 2026, with agents writing synthetic reviews at scale, the shape of a review history is more informative than its content.

The intuition

A real product's rating history is noisy but boring. New products get a small burst of early reviews (friends, enthusiasts, people who buy on launch day), then a long tail. The average drifts slightly as the product finds its audience. Sometimes there's a dip after a bad batch, and a recovery. Human purchasing is lumpy and seasonal.

A manipulated history has a different signature. The most common one looks like this: months of near-silence, then a short window of intense 5-star activity, then back to silence. The aggregate numbers can look great. The trajectory looks like a heart attack on an ECG.

Here's a toy example we use internally for testing:

import numpy as np

rng = np.random.default_rng(42)

# Organic: steady, noisy
organic = np.concatenate([
    rng.normal(4.3, 0.8, 30),   # launch bump
    rng.normal(4.1, 0.9, 90),   # long tail
    rng.normal(3.9, 1.0, 30),   # slight decay
])

# Manipulated: silence, burst, silence
manipulated = np.concatenate([
    rng.normal(3.5, 1.0, 40),   # early genuine reviews, mediocre
    np.full(50, 5.0),           # the burst
    rng.normal(3.6, 0.9, 20),   # back to reality
])

Same count of reviews. Both average around 4.0. One of them you'd buy. The other you'd report.

Decomposing the signal

We compute four features over the full timestamped history. All of them are cheap — no models, no GPU, just statistics you can run in a few milliseconds per product.

1. Burst density. For each sliding window of width w (we use 48 hours for marketplace data), compute the share of lifetime reviews that fall inside it. For an organic product, the maximum window share is bounded — you'd need a viral moment to concentrate 40% of a year's reviews into two days, and viral moments leave traces elsewhere (sales rank, cart-adds, external mentions). For an inflated product, the max window share is often the single most predictive feature we track.

2. Rating entropy. Real reviewers disagree. Even beloved products collect 3s and the occasional 1. A history where 95% of reviews are exactly 5 stars has near-zero entropy, and zero-entropy histories with n > 30 reviews are, in our data, almost never organic. We use Shannon entropy over the discrete rating distribution:

from scipy.stats import entropy

def rating_entropy(ratings: np.ndarray) -> float:
    counts = np.bincount(ratings.astype(int), minlength=6)[1:]
    p = counts / counts.sum()
    return entropy(p, base=2)

A fully concentrated history scores 0.0 bits; a uniform spread over the five star levels scores ~2.32 bits. Organic products cluster between 1.1 and 1.8 bits.

3. Regime change points. We run a simple change-point detection (CUSUM on the mean rating) and look for sharp upward jumps that coincide with volume jumps. A product going from 3.4 → 4.9 average while its review velocity triples is not "improving." Real quality improvements show up in the text and in return-rate signals long before the star average moves a full point.

4. Reviewer overlap. This one crosses products. If 30% of a product's reviewers also reviewed three other products from the same seller — all in the same week — that's a ring, not a fandom. (Cross-product analysis deserves its own post; the short version is that we build a bipartite graph of reviewers × sellers and look for dense subgraphs.)

Why not just use an LLM?

We get this question constantly, including from our own team. Why bother with CUSUM and entropy when a language model can read the reviews and tell you which ones feel fake?

Three reasons. First, cost: we score hundreds of thousands of products; LLM passes per product per refresh would be orders of magnitude more expensive than computing four statistics over a vector. Trajectory features are computed in Postgres with window functions, roughly for free.

Second, determinism: the score a user sees must be reproducible. If someone disputes a trust score, we can show exactly which features fired, what the burst density was, when the change point occurred. "The model said so" is not an audit trail.

Third, trajectory features catch what text analysis can't. The fake reviews of 2026 are fluent, specific, and stylistically indistinguishable from real ones — they're written by models that have read a million genuine reviews. But the timing of a paid campaign is set by a contract and a deadline, not by human enthusiasm. Language can be synthesized. Logistics can't.

The two layers compose nicely: trajectory analysis flags which products deserve scrutiny, and language features (which we do run, selectively) determine whether the flagged text itself is synthetic. Cheap first, expensive second.

The composite signal

Each feature is normalized against a per-category baseline — because a niche hobby product with 60 reviews behaves differently from a phone case with 8,000, and "burst" means different things at those scales. The normalized features feed a logistic scorer whose weights we re-fit quarterly against a labeled set (products removed by marketplaces for review manipulation — the best ground truth available, even if it's conservative).

The output isn't a verdict. It's one input into the composite Smart Score, weighted so that a single suspicious feature can't tank an honest product, but a converging pattern — burst + low entropy + change point + reviewer overlap — pushes the score down hard and fast.

That design decision matters. False positives on legitimate small sellers are the worst failure mode a trust system can have: the seller loses their livelihood, and we lose the credibility that makes the score worth computing. Trajectory analysis earns its keep precisely because it constrains the accusations to products whose histories are, statistically, almost impossible.

What's next

The current frontier for us is reviewer-side trajectories instead of product-side: modeling each reviewer's own history — their entropy, their timing, their category spread — so that a suspicious product's score can be decomposed into "bad product" versus "bad reviewers." Early results are promising and the math is pretty. That'll be the next post in this series.

If you want to see the scoring standard we anchor all of this to, it's public at docs.gobuy.ai/standard — critique welcome, especially the parts about category baselines, which are the hardest thing we've published.

A 48-Hour Burst of 5-Star Reviews Is Never Organic: How We Detect Review Inflation

gobuy.ai — Tue, 13 Oct 2026 08:32:20 +0000

Part of the Trust Engineering series, where we open-source the math behind GoBuy's product trust scores. Code is Python; the ideas are deliberately simple enough to reimplement in an afternoon.

A few weeks ago someone asked us a question that sounds trivial and isn't: "How do you tell the difference between a product going viral and a product being review-bombed with fakes?"

Both look identical at first glance. A product that sat at 40 reviews for eight months suddenly gets 300 five-star reviews in two days. Maybe a TikTok went viral. Maybe a seller bought 300 reviews. The aggregate rating — the only thing most tools look at — moves the same direction in both cases.

The difference is in the shape of arrival times. This post walks through how we detect review bursts, why we score inflation and suppression bursts differently, and the two statistical traps we fell into before landing on the current design.

Why aggregate ratings can't see this

If you average 2,000 reviews, adding 300 more barely moves the mean. That's the whole point of a mean — it's robust to dilution. Coordinated manipulators know this: they don't need to flip your average, they only need to nudge it a few points and keep it there. Aggregates are also memoryless about ordering: a burst at the start of a product's life and a burst last Tuesday produce the same star average.

So the first design decision: treat review arrival as a time series, not a bag of stars.

Step 1: Model arrivals as a Poisson process

Organic review traffic for a mature product is roughly stationary: reviews trickle in at a rate λ proportional to current sales volume. That makes arrival counts in fixed windows approximately Poisson.

For each product we maintain an EWMA of the arrival rate over the trailing 90 days, then test each day's observed count k against Poisson(λ̂):

from scipy import stats

def burst_score(daily_counts, ewma_lambda, window=3):
    """Probability that the last `window` days are NOT explained
    by the product's own organic arrival rate."""
    expected = ewma_lambda * window
    observed = sum(daily_counts[-window:])
    # upper tail: how surprising is this burst, given normal traffic?
    p = stats.poisson.sf(observed - 1, expected)
    surprise = 1.0 - p
    return surprise

A surprise above 0.999 on a mature product means the last three days saw traffic that the product's own history essentially cannot explain. By itself, that's a viral product OR a manipulation campaign. It's a tripwire, not a verdict.

Step 2: Condition the burst on what kind of reviews arrived

This is the step that separates virality from manipulation, and it comes straight from the data: organic bursts are rating-diverse, manufactured bursts are not.

When real humans discover a product, they arrive with real experiences — you get a spread of 4s and 5s, some 3s, the occasional angry 1-star. When a seller buys reviews, they buy one SKU: 5-star, unverified, short text. So we split the burst by rating value and verification status and compute the surprise score per segment:

def manipulation_evidence(burst_reviews, product_baseline):
    five_star = [r for r in burst_reviews if r.rating == 5]
    unverified = [r for r in five_star if not r.verified_purchase]

    # share of burst that is 5-star vs product's historical 5-star share
    five_share = len(five_star) / len(burst_reviews)
    share_uplift = five_share - product_baseline.five_star_share

    # unverified ratio among the 5-star burst
    unverified_ratio = len(unverified) / max(len(five_star), 1)

    return share_uplift, unverified_ratio

Our operating heuristic after tuning on labeled data:

Burst + 5-star share ≥ 0.9 + unverified ratio ≥ 0.6 → inflation campaign. Strong evidence.
Burst + ratings spread matches historical → probably genuine virality. No penalty, just flag for re-scoring.
Burst of 1-stars → review bombing (a competitor, a brigade). Also penalized, but scored separately, because the product may be fine — the review section is what's poisoned.

That last case matters more than people realize. Roughly a third of the bursts we see are negative, and naive detectors that only hunt 5-star spikes misclassify them as "engagement."

Step 3: The trajectory view — bursts in context

A burst in isolation is ambiguous; a burst in a trajectory usually isn't. We bucket every product's rating history into three regimes:

Steady state — arrival rate flat, rating distribution stable.
Step change — arrival rate shifts to a new plateau (price cut, ranking jump, viral moment).
Spike and decay — a burst that fades back to baseline.

The dangerous signature is spike-and-decay with a rating gap: the burst reviews average 4.9 while the pre-burst baseline averages 3.8 and the post-burst reviews snap back to 3.9. Real virality brings in customers whose experiences match the baseline population. Manufactured bursts insert a population whose experiences were never real, so the ratings before and after agree with each other and disagree with the burst. When before/after agree and the burst is the outlier, the burst is the anomaly — regardless of content.

def rating_gap(baseline_before, burst, baseline_after):
    return abs(burst.mean - (baseline_before.mean + baseline_after.mean) / 2)

A gap above ~0.8 stars with burst volume > 10% of lifetime reviews is, in our labeled set, almost always manipulation.

The two traps

Trap one: young products. Everything above assumes an EWMA baseline exists. A product three days old with 200 reviews has no baseline; the burst detector is undefined. For young products we fall back to category priors (how fast do products in this category normally accumulate reviews) — that's a whole separate post.

Trap two: legitimate sales events. Prime Day produces genuine bursts that look structurally like campaigns: volume spike, 5-star heavy, verified though — which is the tell. Verification status is the single highest-signal feature we have, which is also exactly why it's the one the paid-review market has been hardest to fake at scale.

What the agent sees

All of this condenses to one flag and one number in our MCP output:

{
  "smart_score": 31,
  "flags": ["temporal_burst", "rating_gap"],
  "burst": {"window_days": 3, "surprise": 0.9998, "direction": "inflation"}
}

An AI shopping agent doesn't need to reimplement any of this — it needs a reason not to recommend the product, expressed in one line. The full scoring spec is documented at docs.gobuy.ai/standard.

Takeaways if you're building anything similar: model arrivals, not aggregates; condition bursts on rating composition and verification; and always check whether the burst is the outlier relative to its own before/after baselines. The math is 60 lines of Python. The labeled data is the hard part — and the reason we publish the method instead of the model.

Questions, edge cases, or products you think would break this? That's genuinely what the comments are for.

Nobody Reads Reviews Anymore. Not People, Not Agents — So We Built the Reader

gobuy.ai — Mon, 12 Oct 2026 07:35:53 +0000

Salesforce's 2026 holiday data has a line that should stop everyone building shopping agents: 41% of shoppers skip reading reviews entirely when a brand's AI assistant answers their questions.

Not "read fewer reviews." Skip entirely. The assistant's answer replaces the corpus.

Combine that with what was already true — humans never read all 500 reviews anyway; we read the first ten and the star average — and you get the strange situation this post is about:

Nobody reads reviews anymore. Not people. Not agents.

The agent side of the story

It's tempting to think AI agents fix this. They don't — for a mechanical reason: context windows can't afford the corpus either.

A product with 500 reviews averages maybe 150,000 words. An agent doing a multi-product comparison can't ingest that per product and still function. So what do agents actually do? They read the star average, maybe the first few reviews, and reason from the listing copy — which is exactly the shallow read a tired human does at midnight, except the agent does it confidently, at scale, and calls it research.

And the corpus it skims is contaminated. Estimates put fake, incentivized, or AI-generated reviews at 30–40% of volume on major marketplaces. Trustpilot removed 4.5M fake reviews from a single platform in a year. The star average agents inherit is a blend of real sentiment and industrial manipulation.

The trust transfer

Here's the part that should worry the people building those assistants: when a shopper stops reading reviews because the assistant answered, trust doesn't disappear — it transfers. From an open, if polluted, corpus... to a closed one controlled by the seller.

The assistant's knowledge of the product comes from the product page. The product page is written by the seller. The 41% who skip reviews have moved their trust from "what everyone said" to "what the brand told the AI." That's not an AI problem; it's a single-source problem wearing an AI hat.

So we built the reader

At GoBuy we took the obvious-but-awkward position: if no one in the transaction reads the reviews, the reading itself has to be a service.

What "reading" means when a machine does it seriously:

Per-review forensics. Every review gets individual assessment: authenticity signals, Verified Purchase cross-checks, linguistic and temporal anomaly flags. Not corpus vibes — per-item inspection.
Statistical aggregation that respects sample size. A Wilson-interval-style lower bound on the positive rate, so a 5.0 from 10 reviews loses to a 4.6 from 2,400. Sample-size honesty, built into the number. (A statistician publicly caught one of our example numbers being wrong recently; the correction is in our writeup. That exchange is part of how this should work.)
Longitudinal signals. Rating velocity, burst detection, trajectory shape — the distributional evidence that survives even when AI-generated text becomes stylistically undetectable. A brushed product has a shape over time, regardless of how good the fake prose reads.
A disclaimer we actually mean. The output is an Evidence Score: what the marketplace record supports. Not product quality, not safety, not a purchase recommendation. Evidence ≠ quality — and an evidence layer that forgets that becomes just another recommender with better branding.

The two doors

The same reading serves both audiences who stopped reading:

Humans get the score where they shop (browser extension, badges) — the 30-second answer the 500 reviews were supposed to provide.
Agents get it as an MCP tool (check_product_trust, free, keyless) and a spec — GPV-1, eight conditions that should hold before any autonomous checkout. Consent doesn't skip evidence.

Same reader. Same score. Two doors.

The uncomfortable summary

The 2026 holiday season is the first with AI-mediated shopping at scale: Adobe projects $275B online, a fifth of traffic influenced by agents. Every one of those transactions leans on a corpus nobody reads — human or machine.

Somebody has to do the reading. We decided it should be something you can audit.

Try it: the server is open source (MIT) at github.com/gobuy-ai/gobuy-mcp, the endpoint is mcp.gobuy.ai/mcp, and the methodology series continues daily here.

More: https://gobuy.ai

How We Built a Fake-Review Detector Using Wilson Confidence Intervals and Bayesian Inference

gobuy.ai — Sun, 11 Oct 2026 10:35:26 +0000

Can math tell you whether those 4.9-star reviews are real?

Not with certainty — but with confidence, and the difference between the two is where the interesting engineering lives. This post walks through the statistical core of GoBuy's scoring: two layers of classical inference applied to marketplace reviews, what each one is actually for, and the trap hiding in the most obvious approach.

The problem

Amazon lists over 300 million products, and conservative estimates put fake, AI-generated, or incentivized reviews at 30–40% of the total — a share that grows as LLMs make generation free. Existing tools (Fakespot, ReviewMeta) answered this with proprietary black boxes. We wanted the opposite: a system where every number is derivable from first principles, so anyone can audit why a product scores the way it does.

Layer 1: the Wilson score lower bound — sample-size honesty for ranking

The naive average ignores how many reviews it rests on. A product with 10 reviews at 100% positive and a product with 1,000 reviews at 95% positive both "average" near the top — but they are not equally believable.

The Wilson score interval fixes this. For observed positive proportion p over n reviews at 95% confidence (z = 1.96):

lower = (p + z²/2n − z·√(p(1−p)/n + z²/4n²)) / (1 + z²/n)

Worked examples:

480/500 positive (96%) → lower bound 0.939
950/1,000 positive (95%) → lower bound 0.935
10/10 positive (100%) → lower bound 0.72 — a perfect-but-tiny record still leaves real uncertainty

The 10-review product drops below products with hundreds of slightly-less-perfect reviews. That is the point: the Wilson layer is a ranking tool that makes claims honest about their sample size.

One thing this layer is not: a fraud detector. A lower bound on the positive rate measures how liked a product appears to be, not whether the reviews are real — a coordinated burst raises the rate and shrinks the interval, which is exactly what an attacker produces. Fraud detection lives in different signals entirely (velocity, trajectory shape, verified-purchase mismatches — a future post).

Layer 2: the Beta-Binomial model — beliefs that update over time

Wilson gives a snapshot. Reviews accumulate, and we want beliefs that update incrementally.

Treat the true positive rate as a Beta-distributed random variable. Start with Beta(1,1) (uniform — no prior opinion), then each positive review nudges the parameters up:

Beta(α₀ + positives, β₀ + negatives)

480/500 → Beta(481, 21). The 5th percentile of that posterior is 0.9425 — note how close it sits to Wilson's one-sided 0.943 bound. That is not a coincidence: with a flat prior, both layers are functions of the same two counts, and they agree to the third decimal.

So why keep the Bayesian layer at all? Because its value is not in the flat-prior case — it is in what the flat prior can't do:

Real priors. A category-level base rate (e.g., "electronics in this price band average 4.1 stars") gives the posterior something to learn from, pulling thin histories toward category reality instead of letting 10 reviews dominate.
Sequential updates. New evidence arrives daily; the posterior updates in O(1) without recomputing history.
Regime changes. A prior informed by recent behavior makes sudden distribution shifts visible faster.

The honest engineering summary: with Beta(1,1), the Bayesian layer is nearly the same signal as Wilson counted twice — it earns independent weight only when it carries real prior structure and the temporal dimension. That is how it runs in production.

What the composite actually measures

Neither layer measures review authenticity. Together they measure how much the observed rating deserves its number — the evidence-quality backbone of a trust score. Authenticity (burst detection, trajectory anomalies, verified-purchase mismatches) is a separate family of longitudinal signals layered on top, and it deserves its own post.

The composite, briefly:

Wilson lower bound — ranking honesty about sample size (~35%)
Bayesian posterior with category priors — temporal + prior structure (~30%)
Longitudinal authenticity signals — burst, trajectory, provenance (the rest; future post)

Try it

The full corpus runs at gobuy.ai; the gate that consumes it is GPV-1, our open pre-purchase verification spec — one call, check_product_trust, returns the evidence score an agent should see before checkout. The reference implementation is open source.

Corrections: an earlier version stated 0.69 for the 10/10 Wilson example; the correct value is 0.72 (thanks to @arhancanli for catching it). This version also clarifies the division of labor between the two statistical layers, following his equally fair observation that they nearly coincide under a flat prior.