Skip to content

Pricehound - AI Shopping Scout

A private AI shopping scout: write what you need, get an evidence-scored shortlist where every claim keeps its source, then daily price watching.

Problem

Choosing a product means reading Reddit, buyer reviews and expert tests, then checking prices at shops that deliver to you. A language model can do the reading, but only if its claims can be checked against the pages they came from.

Constraints

  • Every claim in a shortlist has to trace back to a source
  • Model spend has to be capped, because a bug in a loop costs real money
  • Shops block scrapers unevenly, so fetching needs fallbacks

Overview

You write one sentence, for example “I need an orthopedic office chair, max 100 euro, delivered to Kosovo”. Pricehound turns it into a brief, researches Reddit, buyer reviews, expert tests and award lists, and builds a shortlist of three to five products. Each product carries an evidence score, and each claim links back to where it was found. After that it watches prices daily at shops that deliver to you and sends a Telegram message with a verdict: buy now, wait, or skip.

It is a private project. The repository is private and the app runs behind a login, so there is no link. The first commit is from 19 October 2026. I set the design, the constraints and the decisions log, and I review the work. Coding agents wrote most of the code.

The pipeline

A hunt runs in steps, and only some of them use a model:

  1. Brief. The sentence becomes a structured brief: category, budget, must-haves, deal-breakers, country.
  2. Plan. The brief becomes search queries and a list of trusted sources for that category.
  3. Search and fetch. No model. Queries become URLs and URLs become pages.
  4. Read. The model reads each page and returns evidence items: which product, for or against, the pros and cons, and a quote.
  5. Judge. Evidence is merged per product and ranked. The judge can answer that there is not enough evidence.
  6. Offers and watch. Shops that deliver to the user, then a daily price run with alerts.

Decisions that carry the design

Evidence is checked in code, not trusted. The reader returns a quote for every evidence item. Code then looks for that quote in the page text, after normalising quotes, dashes and whitespace, and drops the item if it is not there. Very short quotes are rejected because they match anything. The same verbatim check runs on the step that decides whether a shop delivers to a country.

One typed client for every model call. Output is requested as JSON against a Zod schema. The system prompt is cached. If the output is cut off at the token limit, a salvage step closes the JSON and the result is parsed again. Every call is logged with its model, tokens and cost. Haiku is the default model, and Sonnet is an optional upgrade for the judge step only.

A hard daily spend cap. Before a step runs, a guard compares today’s spend plus the step’s estimate with the cap, which defaults to one dollar. If it would go over, the step throws and the hunt pauses. Hunts cannot run away with the budget.

Fetchers chosen from a measurement. I ran seven shop pages through three approaches on one day: a Node HTTP client got 6 of 7, a rendered-page service got 7 of 7, and a scraping API got 7 of 7. The first is the default and the other two are fallbacks, and each site remembers which one worked. It is a small sample from a single day, and it was enough to pick an order.

“Not enough evidence” is an allowed answer. The judge schema has a field for it, and the project rules say never to present a recommendation without its sources.

What I can show

The decisions log and the code are the proof. The repository also has small live evals for individual steps, for example one that judges delivery from saved shipping pages, which I run against real model calls on fixtures. I have not published their results here, and I do not have a user count or an accuracy figure for the shortlists.

Stack

  • Language: TypeScript in a pnpm monorepo
  • Web: Astro with React islands, Tailwind
  • Worker: Node 22 with pg-boss for jobs
  • Data: PostgreSQL with Drizzle
  • AI: Anthropic API, Zod-validated output, prompt caching
  • Alerts: Telegram