# Sloth Errands: an agent that does my web chores while I sleep, and asks before it pays > Source: > Published: 2026-10-23 08:00:22+00:00 *This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady](https://dev.to/challenges/hacktoberfest-week3-2026-10-19).* I have a list of small web chores that I keep forgetting. Renew the library books before they go overdue. Book the 7 AM gym slot the moment booking opens. Check where my parcel is. See if a tool I use shipped a new release. Pay that ₹50 library fine. None of these are hard. They are just annoying, and most of them have to happen at a certain time, usually when I'm asleep or busy. **Sloth Errands** does them overnight. Before bed I tick tonight's chores on a board that looks like a train station's departure board, and go to sleep. An agent built on an open-weight model works through them in cloud browsers: So the lazy person here is me, and anyone like me who keeps getting late fees for things a robot could have done at 2 AM. The safety part is what makes me trust it enough to be lazy. The video is one real, uncut night run, sped up only by demo pacing (retries every 20 seconds instead of every 15 minutes, wake-up in 2 minutes instead of 7 hours). In it you can see: Since it all runs on my laptop, I kept receipts. The demo sites keep their own log of what was actually changed, and the repo's [`evidence/`](https://github.com/Sarcastic-Soul/sloth-errands/tree/main/evidence) folder has the full timeline, the Temporal history screenshots and the Browserbase session list from the recorded run. An agent that does your boring web chores while you sleep. Before bed you pick tonight's chores: renew library books, book the 7 AM gym slot when booking opens, check a parcel, check for a new release. Overnight an agent on an open-weight model (gpt-oss on Groq) does them in cloud browsers. Safe chores finish on their own. A risky step like paying a fine, is held. When you wake up your phone gets an Auth0 Guardian push, you tap Approve, and only then does the agent do that one step. Built for the Hacktoberfest 2026 DEV challenge, week 3 "Slow and Steady". **The model: gpt-oss.** The agent runs on OpenAI's open-weight `gpt-oss-120b`, served by Groq. The small page actions (find this button, click it) run on `gpt-oss-20b`. Both are free on Groq's free tier, which shaped a lot of choices below. **The agent: Mastra.** A Mastra `Agent` gets the chore ("renew every book due in the next 3 days") and five tools: `open_page` and `read_page` to look around`do_on_page` to click or fill something`propose_risky_action` to describe a step it is not allowed to take`finish` to report done, not ready yet, needs approval, or failed The interesting rule is in `do_on_page`. Before any action runs, it is checked against a list of commit words: confirm, pay now, purchase, delete, unsubscribe, cancel my membership and so on. If it matches, the click is refused and the agent is told to propose it instead. That rule is in code, not in the prompt, so a confused model can't talk its way past it. When I approve, the agent gets a fresh run where only that one approved action is allowed. **The browser: Stagehand on Browserbase.** Each site has its own saved Browserbase context, so I log in once (a script fills the demo login by CSS selector) and every later run is already signed in. The model never sees a password. Browserbase also keeps a replay of every session, which is a nice way to check what the agent clicked at 2 AM. My demo sites run on localhost, so a cloudflared quick tunnel gives the cloud browsers a way in. **The waiting: Temporal.** This is the part that makes it "slow and steady". Each night is a `nightWorkflow` that starts one child `choreWorkflow` per chore: All of this is just `await sleep()` and `await condition()` in plain TypeScript, and it survives the worker crashing, which I show in the video. **The approval: Auth0 for AI Agents.** The web app uses Auth0 to sign me in. The morning question uses Auth0's Client-Initiated Backchannel Authentication (CIBA): the workflow calls `/bc-authorize` with my user ID and a short binding message ("Pay INR 50 library fine..."). Auth0 sends the Guardian push, and the workflow polls the token endpoint until I approve, deny, or it expires. The board also has Approve and Deny buttons, which send a Temporal signal after checking that the run is mine. **The board.** Next.js 16 with Tailwind. I wanted it to look like a station departure board: each chore is a departure with a time, a status (ON TIME, DELAYED, HELD FOR YOU, DONE) and announcements underneath. A held step shows up as a ticket you can approve or deny. Some problems I hit: `main` element and 2,500 characters, ran one chore step at a time, and moved Stagehand to the smaller model. An agent that clicks around websites overnight makes a lot of model calls for very little value each. "Is the gym booking open yet?" every 15 minutes, all night, for a whole month. With an open-weight model, that loop costs nothing on a free tier today, and if the free tier goes away I can run the same model somewhere else, or on my own hardware, without rewriting the agent. A closed API would make me count calls and hope the price and the model stay the same. It also matters for trust. This agent holds my logins and can reach a payment button. I can read every line of the stack that sits between the model and that button: Mastra, Stagehand, the Temporal SDK. The safety rule that blocks risky clicks is ten lines in my own repo, not a setting behind someone else's dashboard. Open models and open frameworks let me put the guard rails where I can see them. Five chores, one tap. I approved one push on my phone, and everything else was done by the time I looked at the board. Real-world timing (15-minute retries and polls, a wake-up time in the morning) is one setting away from the demo pacing in the video.