agent.gf.cx — OSS sketch scan

Date: 2026-05-26 Companion: project_agent_gfcx_umbrella_2026-05-26 · feedback_agent_gfcx_hub_of_cards_ui_vision_2026-05-26 Status: Sketch · scaffolding-grade scan to inform Day 1+ decisions, not a recommendation to adopt any of these wholesale.

TL;DR

Two pieces of OSS prior art are directly relevant to where agent.gf.cx is going:

  1. PriceGhost — already does the visual flesh Dan sketched. Card per watched item, 7-day sparkline, live countdown timer to next check, stock-status badge, multi-strategy price extraction with a voting modal when scrapers disagree. Stack is Node + React + Postgres + Puppeteer — not lift-and-shift, but the UI patterns and the voting-extraction idea are worth lifting into our Worker.
  2. Huginn — calls them “agents.” Each agent has a schedule, options, and chains to other agents via an event graph. The “trigger we set” + “go off and report back” language Dan used is literally Huginn’s model, just rendered in Ruby on Rails since 2013. Footprint is heavyweight (RoR + MySQL/PG + Foreman), latest tagged release is 2022-08-18 — don’t run it, but study the agent + event graph as a config language.

Everything else (UptimeFlare, changedetection.io, Glance/Homepage/Homarr) is adjacent prior art — useful for one specific dimension each (Workers-native, content-diff scraping, homelab dashboard widget conventions).

Recommendation for the next pass: - Lift now: PriceGhost’s per-card sparkline + countdown timer + stock-status pill into our compact card--tile. - Lift later: Huginn’s “agent has options + schedule + chains to event-receiver” config shape into src/modules.ts once module #3 lands and the registry shape gets pressure-tested. - Don’t lift: any of the full apps — our Worker footprint is the right home, not a Rails monolith or a Docker stack.

The five projects worth knowing about

1. PriceGhost — closest visual prior art

github.com/clucraft/PriceGhost · 569★ · Node + React + TS + Postgres + Puppeteer (stealth) · self-hosted via Docker Compose

What it does: Self-hosted price tracking across any e-commerce site. Per-product card on the dashboard. Notifications via Telegram / Discord / Pushover / ntfy / Gotify.

UI flesh worth borrowing: - 7-day price sparkline on every card (Recharts under the hood) - Live countdown timer showing minutes/seconds until next check (matches Dan’s “watching while you sleep” framing) - Animated gradient progress bar for time-until-next-check — quietly says “still watching” - Stock-status badge (in-stock / out-of-stock / unknown) as a small pill - Check interval per product — 5 min to 24 hr — settable per card

The Price Voting Modal — the unique idea worth stealing:

Four extraction strategies run in parallel against each page: - JSON-LD schema.org structured data (highest reliability) - Site-specific scrapers (Amazon, Best Buy, Walmart, etc.) - Generic CSS selector heuristics - LLM fallback (Claude / GPT / Ollama analyses page context)

When they agree → automatic. When they disagree, the UI surfaces every candidate price the strategies found and the user picks. This solves the “Apple changed their refurbished HTML again” failure mode noted in ~/Code/agent.gf.cx/CLAUDE.md more elegantly than re-deploying a tweaked regex — the Worker would surface a “needs your call” card instead of going silently dark.

Lift for agent.gf.cx: the sparkline + countdown + stock-badge layout, and the voting-extraction concept as a graceful failure mode for module scrapers.

2. Huginn — the conceptual ancestor of “agents”

github.com/huginn/huginn · 49.3k★ · Ruby on Rails · Docker · last tagged release 2022-08-18 (likely stagnant)

Why it matters even though we won’t run it:

Huginn’s noun is Agent. Every agent has: - A type (RSSAgent, WebsiteAgent, WeatherAgent, TwitterStreamAgent, ScheduleAgent, …) - Options (JSON — URL to watch, keywords, threshold) - A schedule (every N minutes / cron / triggered) - Inputs (other agents that emit events to it) - Outputs (events it emits, consumed by downstream agents)

Agents compose into a directed event graph — exactly the “go off, listen to things, report back, via trigger we set” shape Dan articulated this afternoon, decade-and-a-bit before the term “agentic” entered common usage.

Huginn agents list — every agent is a row with type + schedule + last-event

Huginn directed-graph view — agent A emits an event, agent B consumes it

Huginn detecting peaks in time-series data — the analytical layer above raw checks

Config-language shape (illustrative — Huginn YAML):

agent:
  name: "Mac mini watcher"
  type: WebsiteAgent
  schedule: "every_12h"
  options:
    url: "https://www.apple.com/shop/refurbished/mac/mac-mini"
    extract:
      price: { css: ".as-price", value: "@text" }
    filter: "$.price < 1099"
  emits: "mac_mini_below_threshold"

Lift for agent.gf.cx: not the Rails app. The shape — a module is { name, type, schedule, options, emits, consumes } — should be where src/modules.ts evolves once we have 3+ live modules. Don’t generalise prematurely (per feedback_pattern_library_composes_into_exits.md); revisit at module #3.

3. UptimeFlare — the Workers-native sibling

github.com/lyc8503/UptimeFlare · serverless uptime monitor on Cloudflare Workers · live demo at uptimeflare.pages.dev

What it proves: Workers + KV (now D1) is a viable stack for daily-cadence checks at scale — 310+ geo locations, 100+ notification channels, 90-day history. Same architectural cell as agent.gf.cx.

Worth knowing: - Recently migrated KV → D1 for the history store. Worth watching for our own KV migration when history rows pass ~10k. - Heads-up: CVE-2026-29779 (resolved) — uptime.config.ts shipped to the client could expose monitor credentials. Our src/modules.ts is server-only; keep it that way and double-check nothing leaks via /api/history.

Lift for agent.gf.cx: confidence that Workers can host the long-tail of modules without re-architecting. The status-page rendering pattern is also worth a look when we add public detail pages.

4. changedetection.io — the content-diff specialist

changedetection.io · Python · Docker · self-hosted

The pragmatic incumbent for “any URL, watch for change, alert via Apprise (70+ channels).” JavaScript-rendering via Playwright. Visual selectors for “watch only this div.”

Why it’s relevant: When a future module is “watch this random vendor page for a change” rather than “scrape a specific structured price,” changedetection’s selector + visual-diff approach is the right pattern to imitate. We don’t need to host it — we need to know the mental model exists.

Lift for agent.gf.cx: the per-module choice of structured-scrape vs. content-diff. Mac mini = structured. eBay = structured. “Watch this contractor’s invoice-portal for new entries” = content-diff. The modules registry should tolerate both.

5. Homelab dashboards — Glance, Homepage, Homarr

glanceapp/glance — Go single-binary, YAML config, widget-first dashboard. ~32k★ (Jan 2024 → present). Renders many small panels with very low RAM footprint (~30 MB).

gethomepage/homepage — the homelab-dashboard standard as of 2026, 100+ widget catalog.

Why it’s adjacent prior art:

The “compact card per watched thing, glanceable, click for detail” design language is mature in the homelab-dashboard world. Our hub is that same language applied to watchers instead of services. Where Glance’s widget is “my Plex server’s queue” or “my Sonarr download list”, ours is “Mac mini watcher’s current ask vs target.” The card shape is identical; the underlying signal is different.

Lift for agent.gf.cx: look at Glance’s compact widget layouts (especially RSS / monitor / change-detection widgets) for density tuning when our cards start carrying more data (sparkline, last-3-prices, last-alert-fired).

Honourable mention — Currency-Exchange-Monitor

github.com/currencyexchangemonitor/Currency-Exchange-Monitor — Python + uagents (Fetch.ai’s agent framework) + Twilio SMS — exactly the GBP/USD module shape, in 80 lines. Useful as a reference implementation when we promote the FX placeholder to live: confirms the scraper-layer is trivial and the engineering is all in (a) the source API choice and (b) the alert threshold logic.

Recommended FX sources: - Frankfurter — free, no key, ECB-backed - exchangerate-api.com — free, no key

What I’d ship next on agent.gf.cx (informed by the scan)

Priority Pattern lifted from What it gives us
1 PriceGhost · sparkline on card The Mac mini card stops being numbers-only; you see the 7-day shape at a glance. ~30 mins.
2 PriceGhost · countdown to next check The card says “checking in 4h 12m” — reinforces “watching while you sleep” without an extra widget. ~20 mins.
3 Glance / cards.css · density tuning Once cards carry sparkline + countdown + stock-state, the grid wants tightening from card-grid-min: 240px toward 280–320px. ~15 mins.
4 PriceGhost · voting-extraction modal Apple breaks scraper → card surfaces “3 candidate prices found, pick one” instead of going silently dark. ~2 hrs (sketch), more if we add an LLM fallback strategy.
5 Huginn · agent config shape Refactor src/modules.ts to { name, type, schedule, options, emits, consumes } only after module #3 ships and the current shape feels strained. Not now.

Day 1+ scope cap: items 1 + 2 + 3 before module #2 lands. That’s ~1 hour of work and gets the cards looking like the OSS prior art Dan pointed at.

Memory updates this scan deserves

(Pending Dan’s nod before I write these.)

Source: agent_gfcx_oss_sketch_scan_2026-05-26.md · Rendered 2026-05-26 17:10