New AI model release, paper, or open source (May 23 to 24, 2026)

This window was a Saturday and a Sunday, the two days before US Memorial Day. The loud channels were guaranteed quiet. Here is what that actually means, and the one thing that shipped anyway, read at the commit level with primary sources.

Matthew Diakonov, Written with AI

Published May 25, 20269 min read

Direct answer (verified 2026-05-25)

No major lab made a frontier-model announcement on May 23 or May 24, 2026, and the Hugging Face dated paper indexes for those two days carried no new high-upvote cluster. The window is a Saturday and Sunday running into US Memorial Day, so the announcement and paper feeds were quiet by calendar, not by accident. The only verifiable AI shipping in the 48 hours was at the open-source agent layer, in commits rather than releases. The clearest example: Fazm landed a complete session-interrupt-recovery subsystem across both days, 8 commits and 0 release tags (previous tag v2.9.36 on May 22, next tag v2.9.37 on May 25). Verify against anthropic.com/news, huggingface.co/papers/date/2026-05-23, and github.com/mediar-ai/fazm/commits/main.

The calendar is the story

If you searched for what released on May 23 to 24, 2026, the honest first answer is a date check. May 23 was a Saturday. May 24 was a Sunday. May 25 was US Memorial Day. That is a three-day holiday weekend, and it is the single worst window of any normal week for a frontier-model drop or a wave of new papers.

Lab announcements are run like product launches. They land on Tuesdays through Thursdays, with a press cycle behind them, and essentially never on the Saturday before a federal holiday. The Hugging Face daily papers feed is downstream of arXiv submissions and community upvotes, and both slump on weekends because researchers submit on weekdays. So the loud channels for this window were empty by design. The last weekday burst before it was May 22, whose trending cluster led with DelTA, NVIDIA's Gated DeltaNet-2, and TransitLM. You can see that contrast directly: compare the May 22 dated index against the May 24 one.

Most roundups handle a window like this by skipping it or padding it with the prior weekday's carry-over. That is a dead end for the person who actually wants to know what shipped. The useful move is to drop down one layer, from release feeds to commit histories, where weekend work is still visible because nobody waits for a holiday to stop committing.

0frontier model announcements

0release tags in the window

0interrupt-recovery commits

0prior-context messages (was 20)

The one thing that shipped: interrupt recovery, end to end

On a maintained open-source agent, the weekend was not idle. Fazm (an open-source macOS app that wraps Claude Code and Codex over the Agent Client Protocol) used the quiet two days to take one feature from rough to finished: recovering a chat after the agent stream is interrupted mid-turn. Before this work, recovery replayed text-only prior context and forgot what the agent had actually been doing. By the end of May 24 it could fold the partial response and the last few tool calls back into context, silently, without restarting the conversation.

All of it is verifiable. Run this against a clone of the repo:

git log --since='2026-05-23 00:00' \
        --until='2026-05-24 23:59:59' \
        --pretty=format:'%h %ad %s' --date=short

That returns 27 commits across the two days. Eight of them form the recovery subsystem, and seven of those eight touch a single file, acp-bridge/src/index.ts. Here is the ledger:

Commit	Day	What it does
`df7d4f33` acp-bridge/src/index.ts	May 23	Recover prior context after session interruption Replays prior text context instead of starting from a cold prompt.
`cbc23aec` ChatProvider.swift	May 23	Increase prior context limit to 40 messages Bumped 20 to 40 after feedback that recovery dropped too much; entries capped at 4000 chars each.
`7b2c3c48` acp-bridge/src/index.ts	May 23	Improve session recovery with tool history and partial responses The big one, +133 lines. Adds the RECENT_TOOLS_MAX = 5 ring buffer and partial-response capture.
`da4d458f` acp-bridge/src/index.ts	May 23	Support implicit interrupt recovery and customize preamble text Recovery can fire implicitly on stream loss, and the framing preamble becomes configurable.
`da15488c` acp-bridge/src/index.ts	May 23	Skip session expired notification for implicit recovery Silent recovery: the user does not see a session-expired banner when the fold-back succeeds.
`46bc074b` acp-bridge/src/index.ts	May 24	Support both partial and empty interrupt markers in recovery Handles the case where the interrupted turn has no partial text, not just a truncated one.
`c8371846` acp-bridge/src/index.ts	May 24	Record interrupted tools as cancelled in recent tool summary An interrupted tool is logged as cancelled, not as silently missing, in the ring buffer.
`d6743ff6` acp-bridge/src/index.ts	May 24	Clean up tool history and interrupted sessions on session close Bounds memory: the ring buffer and interrupted-session state are trimmed when a session ends.

Source: github.com/mediar-ai/fazm/commits/main, accessed 2026-05-25.

The mechanism, in three moving parts

The interesting part of this weekend's work is not that recovery exists, it is how it reconstructs a turn after the stream dies. Three pieces do the work, and they are the kind of detail you will not find in any release note because there was no release.

1. A five-slot tool ring buffer

The bridge keeps a per-session ring of the last completed tool calls, capped by a constant the code names RECENT_TOOLS_MAX = 5. When a session is interrupted mid-turn, the recovery preamble can tell the agent which tools it had just run (for example, that it had been running Bash, Read, and Edit on a file) instead of forgetting the work entirely. The ring is consumed once on recovery and trimmed on session close, so it does not grow without bound.

2. A wider, bounded prior-context window

The replay window was raised from 20 to 40 messages on 2026-05-23, after feedback that recovery dropped too much of the conversation. To keep that safe, each replayed entry is hard-capped at 4000 characters, so the worst case is roughly 160k characters of preamble, which fits comfortably in a modern context window. This is the one part of the subsystem that lives in the Swift layer rather than the bridge.

3. Partial-response capture and re-injection

When the interrupted assistant turn was saved with a partial marker by the app, recovery does not throw it away. On an interrupt-triggered cause, the bridge captures the partial text (marker stripped, sliced to 4000 chars) and re-injects it into the preamble with explicit framing, so the agent can resume where it was cut off rather than redo work. The May 24 commits then taught this path to handle the empty-marker case, log interrupted tools as cancelled, and clean themselves up on session close.

Read together, the eight commits are feature-complete: a memory of recent tools, a wider but bounded replay window, and a way to resume a half-finished reply. That is enough to ship as the headline of a minor version. If it appears in a tagged Fazm release in early June, anyone who read it here on the weekend it landed was two weeks ahead of the release feed.

The counterargument

The fair objection is that commit logs are noise and a single project's weekend is not the ecosystem. Both are true. Most commits on most days are refactors and dependency bumps that matter to nobody outside the team, and one agent shipping recovery logic tells you nothing about what the frontier labs are doing.

The point is narrower than that. When the calendar guarantees the announcement layer is empty, the question is not whether the commit layer represents the whole field, it is whether it represents anything real at all. For May 23 to 24, it does: a coherent, finished feature, not a pile of lint fixes. The method is to read one or two projects you actually run, and only lean on their commit history when the loud channels are quiet, as they were by design this weekend. On a loud day you would invert it, reading the announcements first and the commits for detail.

How to run this window yourself

Check the date first. If the window is a weekend or holiday, expect the announcement and paper feeds to be quiet and do not mistake that for nothing happening.
Skim the lab news pages for the range anyway, to confirm. For May 23 to 24 that is a one-minute null result.
Open the dated paper indexes and compare upvote counts to the prior weekday, so you can see the weekend slump rather than guess at it.
Run a date-ranged git log on one or two projects whose stack you run. Group the commit subjects into themes. A theme that spans both days, like this weekend's recovery work, is usually the next release's lead feature.

Want to read your own stack's commit log this way?

If you run or are evaluating an agent setup, book 15 minutes and we will open Fazm together, run the date-ranged git log on a project you care about, and trace this week's commits to next week's feature ships.

Frequently asked questions

What new AI model, paper, or open-source project released on May 23 to 24, 2026?

No major lab (OpenAI, Anthropic, Google DeepMind, Meta, or the large Chinese labs) made a frontier-model announcement on either day, and the Hugging Face dated paper indexes for May 23 and May 24 did not produce a new high-upvote cluster comparable to the weekday before. The reason is on the calendar: May 23, 2026 was a Saturday, May 24 a Sunday, and May 25 was US Memorial Day. Paper submissions and lab posts both fall off sharply across a long holiday weekend. The only AI work that is actually verifiable as shipped in that 48-hour window is at the open-source agent and tooling layer, in commit histories rather than release feeds. The clearest worked example: Fazm, an open-source macOS agent, landed a complete session-interrupt-recovery subsystem across the two days, 8 commits, 0 tagged releases. Its previous tag (v2.9.36) was May 22 and its next tag (v2.9.37) was May 25.

Why were the release and paper feeds empty over May 23 to 24, 2026?

Because the window is a weekend that runs straight into a US federal holiday. Frontier-model announcements are scheduled like product launches and almost never drop on a Saturday or Sunday, let alone the Saturday and Sunday before Memorial Day. Hugging Face's daily papers feed is driven by arXiv submissions and community upvotes, both of which slump on weekends because researchers submit on weekdays. So a dated roundup keyed to May 23 to 24 has nothing to report at the announcement layer not because nothing happened, but because the calendar guaranteed the loud channels would be quiet. Most online roundups handle this by either skipping the window or padding it with carry-over from the prior weekday (the May 22 Hugging Face cluster: DelTA, Gated DeltaNet-2, TransitLM).

What did Fazm's session-interrupt-recovery work actually add across May 23 to 24?

It raised the recovery surface from 'resume after a tool failure' to 'fold partial responses and recent tool calls back into context after an arbitrary stream interruption.' The concrete artifacts, all visible in acp-bridge/src/index.ts: a per-session ring buffer of the last completed tool calls (RECENT_TOOLS_MAX = 5) so a recovery preamble can tell the agent which tools it had just run before the interrupt; a prior-context replay window bumped from 20 to 40 messages on 2026-05-23, with each entry hard-capped at 4000 characters; detection of an interrupt-marked partial assistant turn (saved by the Swift layer) that is kept and re-injected with explicit framing on an interrupt-triggered recovery, instead of being silently dropped; and an implicit recovery path that does not surface a session-expired notification to the user. On May 24 the work was hardened: support for both partial and empty interrupt markers, recording interrupted tools as cancelled in the recent-tool summary, and cleanup of tool history and interrupted sessions on session close.

Where can I verify the May 23 to 24, 2026 events for myself?

For the absence of lab announcements, check anthropic.com/news and the other labs' news pages filtered to those dates. For papers, open the dated indexes at huggingface.co/papers/date/2026-05-23 and huggingface.co/papers/date/2026-05-24 and compare the upvote counts to huggingface.co/papers/date/2026-05-22. For the Fazm commit layer, the public history is at github.com/mediar-ai/fazm/commits/main. On a local clone the exact command is: git log --since='2026-05-23 00:00' --until='2026-05-24 23:59:59' --pretty=format:'%h %ad %s' --date=short. That returns 27 commits across the two days, 8 of which form the interrupt-recovery subsystem, and zero tagged releases in the range.

How many commits versus releases landed in the window, exactly?

May 23 had 23 commits. May 24 had 4 commits. Across both days, zero release tags. The previous Fazm tag, v2.9.36, is dated May 22 in CHANGELOG.json; the next, v2.9.37, is dated May 25. So the entire weekend's shipping lives between two tags and is invisible to any aggregator that indexes releases rather than branches. Of the 27 commits, the 8 that matter for the recovery story are df7d4f33, cbc23aec, 7b2c3c48, da4d458f and da15488c on May 23, then 46bc074b, c8371846 and d6743ff6 on May 24.

Is reading commit logs a reliable way to track AI progress, or just noise?

It is noisy, and most commits do not matter (refactors, lint, dependency bumps). The refinement that makes it reliable is to read the commit log of one or two projects whose stack you actually run, and only reach for it when the announcement layer is quiet. May 23 to 24 is the ideal case: the loud channels were guaranteed empty by the holiday weekend, so the commit layer was the only place real work was visible. On a loud day (a frontier-model drop), the announcement layer carries the signal and commits add detail. The two layers are complementary, not interchangeable.

Why does a 48-hour window with no releases matter at all for someone tracking AI?

Because tagged releases lag the work by one to three weeks, and announcements lag by months. A weekend with zero releases but a complete subsystem landing in commits is a one to two week preview of what the next minor version will contain. The Fazm interrupt-recovery cluster is feature-complete in those 8 commits (ring buffer, 40-message window, partial-response re-injection, marker handling, cleanup-on-close), which is enough to ship. If it appears as the headline of a tagged release in early June, the method that read it on May 24 was two weeks ahead of the release feed.

Does Fazm help me run this kind of dated rundown myself?

Yes. Fazm wraps Claude Code and Codex (and, after the May 22 v2.9.36 release, Gemini) in a native macOS UI, and ships a deep-research skill that runs a multi-phase pipeline of parallel web searches and research subagents, verifies citations where it can, and writes a dated markdown, HTML, and PDF report. Because it runs as the local agent on your machine, the searches come from your IP against live sources rather than a cached newsletter. For a window like May 23 to 24, you can also point the same agent at a local clone and have it run the git-log query above, then cross-check the commit themes against the primary sources.

Related on this site

Guide

Latest AI model releases, papers, and open-source projects (May 22 to 23, 2026)

The adjacent 48-hour window. May 22 was a heavy announcement day (Anthropic Compliance API, the trending Hugging Face cluster); May 23 was the start of this weekend's commit-only shipping.

Read

Guide