# Argus: the intel agent sheds its cron plumbing

*2026-08-27*

> Argus now uses Hermes 0.21 native cron features and bounded GitHub discovery without letting repeated scans inflate its archive.


When I built `personal-intel-agent`, it did one thing: watch a topic, fold duplicate coverage into a single sourced card, and ping only when something materially moved. I later added a second engine for typed metric and price monitoring.

It now has a better name—**Argus**—and a cleaner boundary with Hermes Agent 0.21.

The original version had to carry some of its own scheduler plumbing because cron jobs were effectively stateless. Hermes 0.21 changed that. Cron jobs can now use persistent agent memory, carry the previous run's output forward, skip the LLM when a deterministic source has not changed, keep a bounded per-job notepad, select reasoning effort per job, and deliver directly into a bot's canonical chat.

Argus now uses those native pieces instead of maintaining weaker copies.

## What moved into Hermes

- **User preferences and interests** now live in Hermes persistent memory (`MEMORY.md` / `USER.md` through the `memory` tool), not an Argus-private `memory.md`. One preference now applies consistently across Desktop, CLI, messaging, Bot Mode, and scheduled runs.
- **Previous-run continuity** now uses cron's `continuity=true` (CLI: `--continuity`). Hermes injects the previous final output so Argus can avoid repeating yesterday's briefing and continue incremental work.
- **Simple change detection** can use cron monitor mode (`monitor_script` / `monitor_url`). Hermes hashes the source's exact output and skips both the agent and delivery when nothing changed.
- **Small cursors and watermarks** can live in cron's durable, bounded per-job notepad instead of accumulating tiny one-off state files.
- **Reasoning depth** can be pinned per job with `reasoning_effort`, so a difficult synthesis can think harder without changing the global model setting.
- **Bot delivery** now uses `deliver: bot-chat:<profile>`. The old `notify_bot.sh` subprocess shim is gone. Native delivery creates a real inbound turn in the bot's canonical chat, where the bot can actually respond.

That is the reason for the rewrite: Hermes owns scheduling, memory, gating, and routing better than a skill should. Argus should not duplicate core infrastructure.

## What still belongs to Argus

Hermes 0.21 does not make the intelligence layer redundant. Argus still owns:

- tracker specifications and signal/noise policy;
- source discovery and primary/secondary/tertiary trust ranking;
- durable URL-level deduplication and source provenance;
- semantic folding of multiple reports into one card;
- typed metric comparison and threshold calculations;
- sourced briefing cards with confidence and verification;
- beyond-radar discovery tied to my interests;
- bounded GitHub repository discovery and activity tracking;
- optional actions that run only after a signal passes.

The durable archive stays. Cron continuity carries only the most recent bounded output; it is not a long-term database of every URL already seen. The metric state stays for the same reason: cron's notepad is intentionally small and is not a history store.

## GitHub discovery without archive explosion

GitHub is different from a news site. A repository is a persistent entity that can appear in many searches, on daily Trending, on weekly Trending, and again every time it receives a push. Treating every observation as a new archive item would eventually bury the real signals in snapshots.

Argus therefore uses a separate bounded identity/event model for GitHub repositories:

- canonical identity is case-insensitive `owner/repository`;
- one mutable state record tracks `first_seen`, `last_seen`, `last_pushed_at`, `times_seen`, current stars, and source provenance;
- repeated sightings update state silently;
- API and Trending sightings merge into the same repository record;
- a distinct `pushed_at` transition can create one sparse `new_activity` event;
- star-only changes do not create an event by default;
- candidate, new-repository, and event counts are bounded per run;
- inactive repository state has an explicit retention horizon.

This is the important part: **a weekly re-evaluation of 2,000 repositories does not append 2,000 duplicate archive rows.** Unchanged repositories remain state updates, not new signals. Only meaningful transitions become durable events and possible briefing cards.

The implementation deliberately does not copy GitRadar's scheduler or duplicate cache layout. Hermes owns the daily/weekly cron schedule; Argus owns repository identity, event deduplication, and intelligence output. The full storage contract is documented in the public repository's `references/github-discovery.md`.

## Safety boundary

A high-scoring repository is a candidate for review, not permission to execute code. Argus does not automatically clone, install, import, or run discovered repositories based on stars, a license, or a classification such as `PLUGIN/SKILL`.

That classification means: **worth human inspection**.

## The engines

The news-watch path remains:

`READ → FOLD → SIGNAL → DISCOVER`

It reads ranked sources, suppresses known URLs, folds duplicate coverage, and emits one useful card instead of twenty versions of the same story.

The metric path remains:

`READ → EVAL → SIGNAL`

Its `scripts/eval_signal.py` supports:

- `diff` — fire when a tracked version, date, status, count, or price changes;
- `threshold` — fire only when a numeric delta crosses a percentage or absolute boundary.

The GitHub path adds bounded repository discovery:

`COLLECT → CANONICALIZE → FILTER → SCORE → CLASSIFY → EVENT`

A failed fetch is still reported as an error, never silently reused as an unchanged value.

## Choosing the cheaper path

Not every watch needs the full agent:

- A script whose output should be delivered verbatim is a plain cron `no_agent` job.
- A stable URL or script that only needs interpretation when bytes change uses native monitor mode.
- Several typed metrics requiring thresholds and CHANGED/UNCHANGED reporting use an Argus metric tracker.
- Multi-source news requiring trust judgment, folding, and synthesis uses an Argus news tracker.
- GitHub discovery uses bounded daily collection plus periodic activity re-evaluation; it does not need a second scheduler.

That split reduces pointless model calls without throwing away the parts that require judgment—and prevents “watch everything” from becoming “store everything forever.”

The repository, skill folder, documentation, migration guide, and tests now use the Argus name. The full v0.21 rewrite and bounded GitHub discovery rationale are recorded in the changelog, including what was removed, what was retained, and why.

Source: [github.com/rahlquist/Argus](https://github.com/rahlquist/Argus)