New AI projects on Hugging Face or GitHub, May 26 2026. The change that mattered most was a deletion, not a feature.

Why a dated question rarely has a dated answer

People search for new projects by date because that is how news works, but neither Hugging Face nor GitHub thinks in days. A model card carries a last-modified timestamp, not a launch date. A trending repository climbed because of stars accrued over a week, not because it appeared this morning. The one artifact both platforms agree on is the commit log: an author, a message, and a timestamp to the second that you cannot retouch after the fact without leaving a trace.

That artifact has a second property a trending list does not. It records deletions. A roundup can only point at things that now exist, so the most valuable change a maintainer can make, removing something that was hurting you, is invisible to it. Reading one project's log closely on a single day catches exactly that kind of change. Fazm is a useful subject because it is fully open source, it wraps the real Claude Code and Codex agent loops rather than reimplementing them, and it ships often enough that one day is a real slice of work.

The change: one constant and two call sites, gone

The whole edit lives in Desktop/Sources/Chat/ACPBridge.swift. The agent runs a loop that blocks on the next message from the bridge subprocess. It used to hand that wait a deadline. Now it does not. Most of the 23 added lines are a comment explaining why the deadline was wrong; the actual change is the removal of a single constant and the two arguments that referenced it.

// Inactivity timeout: if no message arrives from the bridge
// for 10 minutes, consider the query stuck.
let inactivityTimeout: TimeInterval = 600
var messageCount = 0
while true {
  let message = try await (sessionKey != nil
    ? waitForMessage(sessionKey: sessionKey!, timeout: inactivityTimeout)
    : waitForMessage(timeout: inactivityTimeout))
  // ...
}

// No inactivity timeout on the steady-state query loop.
// ACP itself defines no timeout (StopReason has no Timeout
// variant). Cancellation is user-initiated via the stop button.
var messageCount = 0
while true {
  let message = try await (sessionKey != nil
    ? waitForMessage(sessionKey: sessionKey!)
    : waitForMessage())
  // ...
}

Commit 787dbb33, 2026-05-26 at 14:31 Pacific. 45 lines changed in one file: 23 insertions, 22 deletions. The companion commit 2aa4a9ce wrote the human-readable note into CHANGELOG.json two seconds earlier.

The argument hiding in the comment

The reason this deletion is more interesting than most additions is that it is justified at the protocol level, not by taste. Fazm drives Claude Code and Codex over the Agent Client Protocol. That protocol enumerates exactly five ways a prompt turn can end:

There is no timeout in that union. You can confirm it in the protocol's own type definitions in the @agentclientprotocol/sdk package, and in the protocol documentation, where cancellation is the client's job and a turn otherwise runs to a model-defined stop. A reference client awaits the response and lets the user cancel; it does not start a stopwatch. Fazm's loop had been inventing a sixth stop reason the protocol never had, and the May 26 change brought the client back in line with the contract.

The pressure to add such a timer is understandable. A loading spinner that never resolves feels like a bug. But the cure punished the symptom it could not distinguish from the disease. A slow model mid-answer and a hung process both present as a quiet pipe. A clock cannot tell them apart. A person watching the screen, with a stop button, can.

What the cap felt like, on either side of the change

The behavior change is small in code and large in experience. Toggle between the two states below.

They did not just remove a safety net

Deleting a timeout is only defensible if something better watches for real failure. The same day's log shows the trade made on purpose: one coarse timer out, several precise signals in. The observability work bracketed the deletion, with audit logging and hot-thread sampling in the morning and finer liveness tracking after the cap came out.

The point of the finer signals is that they fire on the right thing. A per-tool watchdog watches a single tool call, not the whole turn, so a slow model between tools no longer trips it. The heartbeat log now records when an MCP tool has actually gone silent, so a genuine hang is visible in the logs instead of being papered over by a window-wide clock. If the bridge subprocess dies outright, the JSON-RPC pipe closes and the app recovers. None of that needs a 600-second guess.

The supporting commits, if you want to read them

Four commits made the deletion safe. Each is small, dated, and scoped to one file, which is the kind of change you can actually review.

How to read any project's real May 26

The method generalizes to any repository that catches your eye on Hugging Face or GitHub. Skip the README, which is marketing, and read three dated artifacts in order. The changelog, which the maintainer ties to versions. The commit log for the day you care about, which shows what landed and when. Then one diff, where the removed lines tell you as much as the added ones.

Pay special attention to deletions. A project that only ever adds is either very young or not listening; the willingness to take something out, especially a safety mechanism, is a sign someone is actually using the thing and feeling its rough edges. Fazm's May 26 is a deletion justified by the protocol and backed by new instrumentation, which is the most you can ask of a single day in a log.