New AI models, papers, and open-source projects from the last day
The honest answer is that no single page can be current, because the thing you are tracking changes by the hour. So this guide does two things: it names the three feeds that actually refresh every day, and it shows how to point a recurring agent at them so you get the digest delivered instead of going to fetch it.
Direct answer (verified 2026-05-31)
Three feeds update on a daily cadence and between them cover all three categories:
- Models and papers: Hugging Face Daily Papers (date selector, Daily / Weekly / Monthly views).
- Papers: arXiv recent listings (cs.AI, plus cs.CL and cs.LG), sorted by submission date.
- Open-source projects: GitHub Trending with the since=daily and language filters.
Official frontier releases also land on individual lab blogs and model-card pages, but those are scattered. The three feeds above are the dependable starting points, and they are what an automated sweep should read.
Bookmark these. Everything downstream (newsletters, roundups, Twitter threads) is a slower, filtered copy of what shows up here first.
The three feeds that actually refresh every day
Why a daily roundup page is the wrong tool for this
If you search for what shipped in AI in the last day, you get a wall of recap pages. They share a problem: each one is a snapshot of a single moment, written by someone whose interests are not yours, and stale the moment it is published. The feeds above are live. The recap is a photograph of the feeds taken hours ago.
A recap also filters. The author picks the three or four releases they found interesting. The niche repo in your own stack that quietly cut a release overnight will never be in a general recap, because the author has never heard of it. The only way to catch the things that matter to you specifically is to read the feeds through your own context: your follows, your stars, your dashboards.
The reason almost nobody does this by hand is that it is a chore. Opening three sites every morning, scanning long lists, and writing yourself notes is exactly the kind of repetitive loop you put off. That loop is the part worth automating, and it is a better use of an agent than asking a chat model to recite a roundup from its training data.
What the recurring sweep does each morning
The agent reads each feed through your real browser session, not a fresh headless one, then writes a single digest into the same chat you can keep working in.
How the recurring sweep runs, in the actual source
When you ask fazm to run a prompt on a schedule, the agent calls a tool named routines_create, defined in acp-bridge/src/fazm-tools-stdio.ts (around line 547). That writes a row into a local cron_jobs table holding your prompt, a schedule string, and a computed next_run_at. Schedule strings come in three shapes:
cron:0 9 * * 1-5 # weekdays at 9:00 local time every:3600 # every 3600 seconds at:2026-06-01T09:00 # one-shot at an ISO 8601 timestamp
From there it is mechanical. Desktop/Sources/Chat/RoutineScheduler.swift runs a 60-second timer. On each tick it finds due rows and spawns acp-bridge/dist/cron-runner.mjs for each one, with the same Node binary and bridge environment your interactive chat uses, so a headless routine authenticates identically. The runner sends the prompt, captures the result, writes it into cron_runs and chat_messages, and recomputes the next run time. The digest then shows up in your conversation history as if you had asked for it yourself.
The browsing itself uses the same tools as any interactive chat: mcp__playwright__browser_navigate to load a feed and mcp__playwright__browser_snapshot to pull the page's accessibility tree (structured text, not a screenshot) so the agent can read the list, follow into a paper or model card, and summarize it. All of this is open source; you can read github.com/mediar-ai/fazm before trusting a routine to drive your logged-in sessions.
Set up your daily AI sweep in four steps
Open a chat and describe the sweep in plain English
Tell the agent what you want and when. For example: 'Every weekday at 9am, open Hugging Face Daily Papers for today, arXiv cs.AI recent, and GitHub Trending filtered to Python since:daily. Summarize anything about agents, local LLMs, or macOS into a short digest.' The agent turns the natural-language timing into a schedule string for you.
The agent creates the routine
Under the hood it calls routines_create (fazm-tools-stdio.ts), which writes a cron_jobs row with your prompt, a schedule like cron:0 9 * * 1-5, and a computed next_run_at. Set session_mode to 'resume' if you want the agent to remember yesterday's digest and only report what changed.
RoutineScheduler fires it on time
A 60-second timer in RoutineScheduler.swift finds the due row and spawns cron-runner.mjs with the same bridge environment your interactive chats use. The agent loads each feed in your real logged-in browser via the Playwright extension and reads the page content.
The digest lands in your chat
cron-runner.mjs writes the result into chat_messages, so the morning digest appears in your conversation history exactly as if you had asked for it. If one item is worth a deeper look, fork the chat in one click and start working without losing the digest.
The constraint nobody mentions: it runs only while your Mac is on
Routines run locally, through the bridge, using your own Claude or Gemini credentials, your files, and your logged-in browser. That is deliberate: your screen, your mic, and your sessions never leave the machine, and there is no third-party server holding your cookies. The cost of that design is real and worth stating plainly instead of hiding it: there is no cloud worker, so a routine only fires while the app is running.
Fazm handles the obvious failure mode (your Mac was asleep at 9am) with catch-up-once behavior. A routine whose scheduled time passed while the app was closed keeps its next_run_at in the past and fires once on the next 60-second tick after launch, the same way Claude Code's /loop catches up. So you get the digest when you open your laptop, not a pile of missed runs. Concurrency is capped at three simultaneous routine bridges, because each one is a full ACP bridge that uses around 600MB; extra due jobs keep their past run time and fire on the following ticks.
If your honest requirement is a sweep that runs at a fixed hour whether or not you are at your desk, a local menu-bar agent is the wrong shape and you want a server-side cron job hitting the same APIs. If your requirement is "read the feeds through my actual logged-in accounts and hand me a digest the moment I sit down," the local routine is exactly right, and it is the tradeoff most individual developers actually want.
Want a sweep tuned to your stack?
Book a short call and we'll set up a daily routine that reads the feeds you care about in your own browser and writes you a digest.
Frequently asked
Where do new AI models, papers, and open-source projects from the last day actually show up first?
Three feeds refresh on a daily cadence and between them cover all three categories. Hugging Face Daily Papers (huggingface.co/papers) is community-curated, has a date selector, and a Daily / Weekly / Monthly toggle; it surfaces both new models and the papers behind them. arXiv recent listings (arxiv.org/list/cs.AI/recent, plus cs.CL and cs.LG) are the raw academic pipe, sorted by submission date, where most papers land before anyone writes them up. GitHub Trending (github.com/trending, with a since=daily filter and a language filter) is where new open-source projects and tools spike. Lab blogs and model-card pages are where the official frontier releases get announced, but they are scattered, so the three feeds above are the dependable daily starting points.
Why not just read a 'last 24 hours in AI' roundup page?
Because a roundup is a snapshot of one moment, written by someone whose interests are not yours. By the time it is indexed it is hours or days stale, it filters to whatever the author cares about, and it never includes the niche repo in your stack that quietly shipped a release overnight. The feeds update continuously; the roundup does not. If you want to actually stay current rather than read about a day that already passed, you sweep the feeds yourself. The only reason most people don't is that doing it by hand every morning is tedious, which is exactly the part an agent removes.
What does fazm add over opening the three tabs myself?
Two things. First, it removes the manual loop: a routine fires on a schedule, opens the feeds in your real browser, reads them, and drops a digest into your chat without you touching the keyboard. Second, it reads YOUR logged-in browser through the Playwright MCP Bridge extension, so the agent sees what you see (your Hugging Face follows, your GitHub stars, your private dashboards) rather than a fresh headless instance with no session. The agent loop is the real Claude Code (or Codex) wrapped in a native Mac app, so the same chat that ran the sweep can immediately go clone a repo or summarize a paper.
How does the recurring routine actually run under the hood?
When you ask fazm to run something on a schedule, the agent calls the routines_create tool defined in acp-bridge/src/fazm-tools-stdio.ts (around line 547). That writes a row into the local cron_jobs table with your prompt, a schedule string, and a computed next_run_at. RoutineScheduler.swift then polls every 60 seconds, finds due rows, and spawns acp-bridge/dist/cron-runner.mjs for each one, using the same Node binary and bridge environment that interactive chat uses. cron-runner.mjs runs the prompt to completion, writes the result back into cron_runs and chat_messages (so the digest shows up in your conversation history), and recomputes next_run_at. Schedule strings come in three shapes: cron:<expr>, every:<seconds>, and at:<ISO 8601>.
What is the one constraint that other guides skip?
Routines run locally, through the bridge, using your own Claude or Gemini credentials, your files, and your logged-in browser. That is the whole point (your screen and session never leave the Mac), but it has a cost: the routine only fires while the app is running. There is no cloud worker. If your Mac is asleep or the app is quit at 9am, the run does not happen in the cloud. Fazm handles this with catch-up-once behavior: a routine whose scheduled time passed while the app was closed keeps its next_run_at in the past and fires once on the next 60-second tick after launch, the same way Claude Code's /loop behaves. Concurrency is capped at three simultaneous routine bridges because each one is a full ACP bridge (~600MB).
Does the sweep keep its context, or does it compact like a long CLI session?
If you set the routine's session_mode to 'resume', consecutive runs share one ACP session, so the agent remembers what it told you yesterday and can say 'nothing new since the last digest' instead of repeating itself. Inside any single window there is no auto-compacting: the full conversation stays live in context for the lifetime of that window. And if a digest turns into real work (you want to dig into one paper or clone one repo), you can fork the chat in one click into a new window that carries the full prior context while leaving the original sweep untouched.
Can the agent read arXiv and Hugging Face, or just open them?
It reads them. The browser tools the agent drives include mcp__playwright__browser_navigate to load a feed and mcp__playwright__browser_snapshot to pull the page's accessibility tree (the structured text content, not a screenshot). So the routine can open huggingface.co/papers for today's date, read the list, follow into the papers or model cards that match your interests, and summarize them. Because it works off the accessibility tree rather than pixel screenshots, it reaches the same content a screen reader would, which is more reliable than image parsing for dense list pages.
Is fazm open source, and where is the routines code?
Yes, the whole app is open source at github.com/mediar-ai/fazm. The routine scheduler is Desktop/Sources/Chat/RoutineScheduler.swift, the per-run executor is acp-bridge/src/cron-runner.mjs, the schedule parsing and next-run math live in acp-bridge/src/schedule.mjs, and the agent-facing tools (routines_create, routines_list, routines_update, routines_remove) are in acp-bridge/src/fazm-tools-stdio.ts. You can read exactly what a routine does before you trust it to drive your logged-in browser, which matters for anything that clicks around inside your authenticated sessions.
Narrower versions of this question
Latest AI model releases in the last 24 hours: where to watch, and how to run one day one
The model-only version of this question: the trackers that stay correct, and the exact runtime path to run a just-shipped model on a Mac the day it lands.
Open-source AI projects, tools, and updates from the past day, told in commits
The projects-only version: how to read a single day of open-source AI movement through the changelogs and commits that actually shipped.
Open-source AI project releases on May 25, 2026: what actually shipped
A worked example of pinning one specific day down to a verifiable, dated changelog entry instead of a vibe-based recap.
Comments (••)
Leave a comment to see what others are saying.Public and anonymous. No signup.