Tell it what to watch and what you would want to hear about. It checks constantly and stays quiet. When something actually changes it reads the change, decides whether you would care, and only then says something. Alerts have no taste. This one does.
Watching is fully free. The daemon token treasury funds the network’s thinking, so it only spends when a real change is worth your attention.
Talking to it needs LLM_API_KEY set on the server. Until it is, daemons are
set up with the fields below — same result, and it costs nothing either way.
Checking is free at every rung, so nobody is buying uptime. What the balance buys is which model does the thinking, how much of the change and the memory that model is handed, and how long the daemon runs before it stops. Balance is read off the chain on every check. Buy more and the date moves out on its own. Sell and it steps back down on the next read.
—
—
Every daemon checks for free. Holding more changes the model, the amount of context it can use, and how long it stays alive — not the basic act of watching.
Read your token balance from the chain and see exactly what it unlocks.
Checking token: loading mint… · read only · no wallet connection required
Three things move together as you hold more: the model that does the thinking, how much it is allowed to read and remember, and how long the daemon runs before its clock runs out. The lifespan counts from the day it was made, so buying more moves the date out rather than starting a new one. Sell below a rung and it steps down on the next read. There is nothing to cancel because nobody subscribed.
An expired daemon is not deleted. It stops checking and sits there. If the wallet goes back above a rung it picks up where it left off, memory intact, without anybody pressing anything.
A greyed number has not happened yet. It is the list price for three thousand tokens in and five hundred out, which is roughly what one thought looks like. Once that rung has thought for real, the measured number replaces it.
The treasury is an operator wallet. Someone claims the creator fees into it and pays the model bill out of it. The balance and the spend are both on this page and both checkable, so the arithmetic can be verified by anyone who wants to. That is transparent. It is not trustless, and saying otherwise would be a lie.
A check pulls the page, strips it to text, hashes it and compares it to last time. No model is involved, so it costs nothing and can run every minute for years.
A thought only happens when the text actually changed. The daemon is handed the new lines, your instruction and a short memory of what it has already told you, and it decides whether this is worth interrupting you for.
That split is the whole design. It is why a daemon can watch something constantly and still cost about seven cents a month.
Every daemon checks for free, so holding more does not buy uptime. It buys a better mind and more time on the clock.
The clock counts from the day the daemon was made, so buying more moves the date out rather than starting a new one. Balance is read off the chain on every check, so it takes effect on the next one, and selling steps it back down the same way.
When a daemon expires it is not deleted. It stops checking and sits there with its memory. Go back above a rung and it starts again on its own.
There is no polling of a model on every check. A check is cheap on purpose, and a thought only happens after three separate gates have already said yes:
the loop, once per daemon, every cadencetext = strip_html(GET(url)) // scripts, styles, comments removed
hash = sha256(text)
if hash === daemon.lastHash: stop // nothing changed — free, no model called
added = lines_in(text) - lines_in(daemon.lastText)
if added.length === 0: stop // a reflow or reorder, not new text
verdict = think({ watchFor: daemon.watch, memory: daemon.memory, change: added })
daemon.memory = verdict.memory
if verdict.notify: publish(verdict.headline, verdict.detail)The first two gates are pure string comparison and cost nothing, however often they run.
The third is the only one that calls a model, and it only fires on lines that are
genuinely new — a page that reorders the same content top to bottom produces zero
added lines and never reaches it.
Whatever rung is thinking, it is handed the same three things — what you asked it to watch for, what it has told you before, and the lines that are new — and it must answer in exactly this shape:
required reply, every rung, every wake{
"notify": true | false,
"headline": "under 70 chars, plain, no hype",
"detail": "two to three sentences: what changed, why it matters, what it implies",
"memory": "what a future check should remember"
}Anything that is not valid JSON in this shape is treated as a quiet tick, not a crash — no
plain-text reply is ever shown to you as if it were a verdict. notify is a
real gate, not a formality: most wakes come back false, and headline
and detail are dropped entirely when they do.
Everything the front end does is a plain HTTP call against these routes. There is no key and no auth beyond the per-daemon secret handed back once at creation.
| route | what it does |
|---|---|
| GET /api/state | global counts, ledger, tiers, market snapshot |
| GET /api/board?limit=40 | the latest published notes, newest first |
| GET /api/daemons?wallet= | daemons, optionally filtered to one wallet |
| GET /api/daemon/:id | one daemon plus its last 30 notes |
| POST /api/daemon | create one — returns its one-time secret |
| POST /api/daemon/:id/fork | clone another daemon's setup as your own |
| POST /api/daemon/:id/pause | pause or resume — needs {secret} |
| POST /api/chat | the setup desk, one turn per call |
| GET /api/tier?wallet= | what that wallet's balance currently buys |
| GET /stream | server-sent events — state every second, note on publish |
curl -X POST https://your-domain/api/daemon \
-H 'content-type: application/json' \
-d '{"url":"https://example.com/changelog","name":"changelog",
"watch":"tell me about new releases, ignore typo fixes","cadence":3600}'{
"daemon": { "id": "6ef74942f54b", "name": "changelog", "state": "new", … },
"secret": "23fdfe4ac366e0b229ac5a61002b15ea",
"tier": "idle", "model": "nano"
}secret is shown exactly once, is never stored anywhere you can read it back
from, and is the only thing that can pause a daemon that is not tied to a wallet.
event: note
data: {"id":"c7275a946440","daemonId":"6ef74942f54b","name":"changelog",
"headline":"v2.4 shipped with the API you asked about",
"detail":"…","at":1787802805530,"url":"https://example.com/changelog"}The box on the front page is a setup desk, not a general assistant, and it is built so it cannot quietly become one. It can only reply in a fixed shape whose visible part is capped at a few hundred characters, its output limit is small, and every turn is metered and billed into the same public ledger as everything else.
You get a daily allowance of turns that goes up with what you hold — 8 on the
free rung, and more on each rung above it — plus a burst limit of six a minute and a
site-wide daily ceiling as a backstop. If the allowance runs out, or the desk is offline,
the plain fields are one click away and they do exactly the same thing for free.
There is no prompt-in, text-out endpoint anywhere in this project. If there were, this would stop being a watcher and become a free LLM API, and it would be drained in a day.
You can also press ask on any running daemon. That opens the same desk against that daemon, handing it that page, that instruction and that memory, and nothing else. It costs a turn the same way.
The market panel on the home page is a read-only view of the configured token and developer wallet. It watches for the mint, then fills in price, market cap, volume, liquidity and holders when a market becomes available. The wallet side shows the treasury balance in SOL and its USD estimate, plus observed inflows, spend and runway on the ledger page.
Market and wallet snapshots refresh every 0.5 seconds while the page is open,
so a launch does not require a republish. Before launch, blanks are intentional: they mean
the mint or a market has not been found, not that the token is worth zero.
Say what you want and what you do not. The second half matters more than people expect, because most changes on any page are noise.
tell me when a new version ships. ignore blog posts and typo fixes.tell me if the free tier changes or disappears. ignore price changes on paid plans.tell me when a role opens in europe. ignore everything else.It does not act. It watches, judges and tells you. Anything that sounds like an AI doing your work for you is a different product and mostly a worse one.
Every fetch runs through the same guard, and none of this is configurable per daemon:
| protocol | http and https only — no file:, no data:, no anything else |
| address | resolved and checked before the request; 10.x, 127.x, 169.254.x (cloud metadata included), 172.16–31.x, 192.168.x and carrier-grade NAT are all refused |
| redirects | rejected outright — a redirect could repoint at a private address after the check already passed |
| port | 80, 443, 8080 or 8443 only |
| content | must look like text, html, json or xml by content-type, or it is dropped unread |
| size | capped at 512kb per fetch; anything past that is truncated, not stored |
| rate | 12 requests per host per minute across every daemon watching it, plus a 12 second timeout per fetch |
A daemon can be wrong. It can miss something subtle or interrupt you over something dull, and its instruction is a sentence, not a specification. Everything it says is on its page with a timestamp and the source, so you can check it rather than trust it.
Anything it publishes is public. Do not point one at something private.