Self-scheduling agents

What "self-scheduling" actually means

Most watching tools run on a fixed timer the human picked: every 15 minutes, every hour, every day. That timer is a guess. Guess too often and you waste compute on a page that never changes. Guess too rarely and you miss the announcement by a day.

A self-scheduling agent picks its own cadence. Each run, it decides when to come back based on what it just saw. Heating up? Sooner. Quiet? Later. Permanently resolved? Never. The schedule is an output of the agent, not an input from you.

It also decides when to tell you. Not every run produces a notification — only the runs where something is actually worth saying. The agent is the editor, not just the sensor.

How it differs from cron + scrape

Traditional watching fires on a fixed cadence and compares two snapshots. Bytes change, alert fires. That breaks on dynamic pages, noisy layouts, A/B tests, cookie banners, and anything gated behind JavaScript the scraper can't execute. It also has no concept of the thing you actually care about — only "did the bytes move?"

A self-scheduling agent grounds every run in live search. It looks for fresh evidence, reads the relevant pages, and reasons about whether your natural-language condition ("Apple announced a release date", "the API docs are public", "the price dropped below $40") is satisfied. Layout churn doesn't fool it. Neither does a page that loads its real content from JavaScript.

The cadence adapts to what the agent finds. Clear evidence the moment is near earns an earlier next look. A long stretch of nothing earns a longer interval. You never tune a polling rate.

Inside webwhen's loop

Each watch is defined by a condition you write in plain English. When the scheduler fires it, the backend hands the condition to a Pydantic AI agent over an A2A protocol. The agent does grounded search, optionally fetches specific pages for more context, and produces a typed response.

That response carries: whether the condition is met, a short human answer, the agent's reasoning, citations to the sources it actually read, and a `next_run` timestamp. The backend persists everything, sends a notification when the agent says one is warranted, and reschedules the watch for the time the agent picked.

When the agent decides the condition is permanently resolved, `next_run` comes back null. The watch transitions to done and stops consuming compute. You hear about it once, when it matters, and then the watch quietly retires itself.

Where this shape fits

Self-scheduling agents are the right shape when the question requires interpretation, when the answer might appear on pages you haven't enumerated in advance, and when checking too often would be wasteful or rate-limited. Release date watches, regulatory announcement watches, price-drop watches, exchange listing watches, "did they finally publish the docs?" — all of these fit.

They are the wrong shape when you already know the exact URL and the exact DOM selector, the page is stable, and you want raw change detection with no judgement involved. A plain scraper is cheaper and simpler. Use the right tool.