New AI projects on Hugging Face or GitHub, May 18 2026. A wrapper finally let you edit a previous message in a Claude Code session.
Trending lists show what landed with a stars-per-hour spike. They cannot show you what a project actually decided on a given day. On May 18, 2026 the open-source macOS agent Fazm pushed 50 commits, and the load-bearing one adds an 85-line method to ChatProvider.swift that does the single thing the raw Claude Code CLI cannot do in a live session: edit a previous user message, truncate everything below it, and resend.
Direct answer, verified 2026-05-26
No platform publishes an official "May 18, 2026" list of new AI projects. Both Hugging Face and GitHub order discovery by a rolling trending score, not by calendar date. New work surfaces continuously across three live feeds:
- huggingface.co/models sorted by trending, for weights and quantized variants.
- huggingface.co/papers, for research with implementations linked.
- github.com/trending, for the agent code, harnesses, and applications.
For one verifiable record carrying that exact date: Fazm pushed 50 commits to github.com/mediar-ai/fazm on 2026-05-18. The headline is commit 04a2a144, an 85-line addition to Desktop/Sources/Providers/ChatProvider.swift that implements editAndResubmit, plus 13 UI commits that put a pencil button on every previous user message. The rest of this page traces what that method actually does.
Why an edit affordance is the May 18 headline
ChatGPT has had message editing since late 2022. Claude in the browser has had it for almost as long. Both let you scroll back, click a pencil, rewrite a previous user turn, and rerun the conversation forward from there. The raw Claude Code CLI does not. Running it the way most people do, you cannot select turn five of a session and rewrite it. You can clear the session and start over, or you can resume a different session id, but neither of those is the same affordance. They are tear-downs, not edits.
The reason this matters for an agent that drives your machine is that long sessions accumulate context fast. By turn ten the agent has read files, run shell commands, opened the browser, and made decisions based on a question you phrased imprecisely on turn three. Without an in-place edit, the cost of correcting that phrasing is the cost of redoing every tool call after it. With the May 18 change, it is one click on a pencil, one new sentence, and forward.
What the new method actually does, in six steps
editAndResubmit(messageId:newText:sessionKey:) is annotated with a six-line inline comment that names the contract: truncate at messageId, tear down the upstream ACP session, resend newText as a fresh query, and let sendMessage rebuild priorContext from what survived. Here is what each of those six steps does on the wire.
editAndResubmit pipeline
1. Find the message
messages.firstIndex(where: { $0.id == messageId && $0.sender == .user }). If the id is not in the live messages array, the call returns early with a log line. The cutoffDate is the createdAt timestamp of the matched message, used in step 2 for the persisted store.
2. Truncate in-memory
messages.removeSubrange(idx...). The edited message and every reply after it disappears from the array the rest of ChatProvider reads, so the moment the UI re-renders, those turns are gone from the visible chat.
3. Truncate persistence
await ChatMessageStore.deleteMessagesFromTimestamp(context: ctx, cutoff: cutoffDate). The context string is __floating__ for the floating bar, __detached-<key>__ for each pop-out window. The store deletes every row at or after cutoffDate so a restart cannot resurrect the truncated turns.
4. Reload visible history
barState.streaming.loadHistory(from: visibleMessages) for the floating bar, or the same call on every DetachedChatWindow entry that matches the sessionKey. This is the moment the on-screen chat bubbles redraw to match the truncated state.
5. Close the upstream ACP session
await acpBridge.closeSession(sessionKey: key). The bridge tears down the underlying Claude Code session and clears the stored upstream session id for that key (floating, main, or detached-*). The next prompt creates a fresh ACP session rather than trying to resume a session whose transcript no longer matches what the UI shows.
6. Send as a fresh query
await sendMessage(trimmed, sessionKey: sessionKey). priorContext is rebuilt inside sendMessage from the truncated ChatMessageStore (last ~20 turns, text-only summary), and the new text becomes the next user message. The model continues from immediately before the edited turn, with the rewritten wording.
Before May 18 vs. after, on the same machine
The change is small if you read it as one method on one class. It is large if you read it as the closing of a gap between the desktop agent and the chat surfaces people already trust. Three states of the world, side by side.
Raw Claude Code CLI
No edit on a previous user message. The options are /clear and start over, or /resume with a different session id which is a fork, not an edit. To rewrite turn five of a session, you scroll back through the transcript, copy the rest of your thoughts, abandon the session, and retype it as a new conversation.
Fazm before May 18
Same constraint. The floating bar bubbles were rendered, the message ids were already stored on every exchange, but no path existed from a click on a previous user message back into ChatProvider with a new query. The pencil button was not there. You could fork the whole chat into a new window, or stop and retype.
Fazm after May 18
Every previous user bubble grows a pencil affordance. Clicking it swaps the bubble for an inline composer pre-filled with the original text. Submit triggers editAndResubmit. The chat below it disappears, the upstream Claude session is replaced, and the rewritten message goes out as the next turn with priorContext rebuilt from everything that came before.
Fork vs edit, the honest difference
Fork keeps both branches and opens a second window. Edit destroys the original branch and continues forward. Both have a use. Pre-May 18, only fork existed. After May 18, both exist, and the choice is a single button click rather than a multi-step copy-and-paste dance.
“priorContext replay sends text-only summaries (no tool calls or thinking blocks, capped to ~20 turns), so the resumed conversation can diverge from one that ran normally, especially on tool-heavy turns.”
Inline comment above editAndResubmit, ChatProvider.swift, commit 04a2a144, 2026-05-18
The fidelity caveat the team chose to write down
The most honest line in the diff is the warning, not the mechanism. priorContext is text-only. It carries the user and assistant turns as summarised text, not the tool calls the assistant ran or the thinking blocks the model produced along the way. It caps at roughly the last 20 turns. So a session that ran a long browser automation chain, then got edited at turn three, will not perfectly reconstruct the tool state on the resumed side. The next answer may differ from the answer the model would have given if you had phrased turn three correctly the first time.
That is not a flaw to hide. It is a property of how Anthropic persists agent sessions through the SDK, and the right place to surface it is in the code comment for the method that assumes the cost. Future readers see what they are signing up for when they reach for the pencil, and the function name does not over-promise.
Where edit fits next to fork
Fazm already had a one-click fork. Click the fork button on a chat, and a new window opens with the full prior context preserved, while the original window keeps running untouched. Fork is preservation. Edit is replacement. They are not redundant, and the May 18 work does not remove fork. It adds the second verb so you can pick the right one for the situation.
Use fork when you want to explore a different direction without losing the path you were on, for example when you are about to ask the agent to delete files and you want to keep the version of the chat that did not. Use edit when you are correcting a wording mistake that sent the conversation somewhere you do not need to keep. The difference between the two is a sentence in the docs and a click on a button in the UI. Most chat surfaces flatten both into one affordance and call it editing. Keeping them separate is a small piece of taste worth noting.
The other forty-nine commits
The edit pipeline shared the day with three other themes. One: a 1M-context model entitlement guard. The picker used to offer Sonnet and Opus 1M-context variants to every Claude account, and many plans do not include that entitlement, so the call would fail with a hard "usage credits are required for long context requests" error and no recovery. After May 18 the picker hides those variants from accounts that lack the flag, and a new model_entitlement_missing event from the bridge lets the UI explain the failure when it still slips through.
Two: ACP bridge warmup state, surfaced into the floating bar and the onboarding chat. The bridge takes a beat to spawn a Node process and connect to the Claude SDK, and on cold launch that beat used to look like a frozen chat. After May 18 the UI shows a "starting" status from the moment the bridge process begins until it signals warmupComplete, with diagnostic fields surfacing the failure mode if the spawn never lands.
Three: a new browser-harness MCP server, bundled into the app along with a managed-browser mode in Settings. The agent can now drive a controlled Chrome window on port 9655 without taking over the user's normal browser, which is the half of "computer use" that needs a sandbox more than it needs raw capability. None of those would surface on a trending feed. All of them are visible in the commit log for 2026-05-18, tagged with descriptive messages and exact timestamps. The dated question is really asking about that density, and a trending list is the wrong tool for the job.
How to read any project's real May 18
The method generalises to any repository on Hugging Face or GitHub that catches your eye. Skip the README, which is marketing. Read three dated artefacts in order. The changelog, which is authored by the maintainer and tied to versions. The commit log for the day you care about, which shows what landed and when. Then one diff, where the inline comments tell you why.
For Fazm on May 18, 2026, that chain is 50 commits in github.com/mediar-ai/fazm with timestamps spanning roughly twelve hours Pacific, four named themes across them, and one diff (commit 04a2a144) whose 85-line method closes the gap between a CLI agent and a chat. That is the texture a dated question is really asking about, and it is the kind of answer no trending page can hand you.
Bring a Claude Code workflow you wish had edit-in-place
In twenty-five minutes we open the chat surface together, walk through where the pencil lands, and decide whether dropping the raw CLI for a wrapper is the right call for your day.
Frequently asked questions
What new AI projects appeared on Hugging Face or GitHub on May 18, 2026?
Neither platform publishes a dated release list. New models, datasets, papers, and repositories surface continuously across three rolling feeds: huggingface.co/models sorted by trending for weights, huggingface.co/papers for research with implementations linked, and github.com/trending for the application layer. As one verifiable commit-level record carrying that exact date, the open-source macOS agent Fazm pushed 50 commits to github.com/mediar-ai/fazm on 2026-05-18. The headline change is commit 04a2a144, which adds the editAndResubmit method on ChatProvider.swift, an 85-line implementation of an affordance the raw Claude Code CLI does not have: editing a previous user message in a live session and resending it.
What was the single most consequential change Fazm shipped on May 18, 2026?
Editing and resubmitting a previous user message in a running chat. The new method editAndResubmit(messageId:newText:sessionKey:) lives in Desktop/Sources/Providers/ChatProvider.swift starting at line 1742, and it runs a six-step pipeline: find the message by id in the in-memory messages array, remove every message from that point onward, ask ChatMessageStore to delete the same range from persistence by timestamp, reload the truncated history into whatever pop-out window the chat lives in, ask the ACP bridge to close the upstream session so the next prompt creates a fresh one, clear the stored upstream session id so the bridge does not try to resume the old one, then call sendMessage with the new text which auto-builds priorContext from the now-truncated history. The thirteen UI commits around it light up the pencil button on every previous user bubble and route the click into that method.
Why does this matter when ChatGPT has had message editing since 2022?
ChatGPT and Claude in the browser have had message editing for years. The Claude Code CLI does not. Running raw, you cannot select a previous message and rewrite it. You can /clear and start over, or you can use /resume with a different session id, but neither of those is editing a turn in place. The whole point of a wrapper that runs the real Claude Code agent loop is to keep the loop and fix the parts that hurt. May 18 ships one of those parts.
What is priorContext, and how does the truncated history end up in it?
priorContext is the text-only summary of recent turns that Fazm passes into a new ACP session when it has to create one mid-conversation, so the model starts the next turn already knowing what came before. It is built inside sendMessage from the floating bar's or pop-out window's persisted ChatMessageStore, capped at roughly the last 20 turns. After editAndResubmit truncates the store at the edited message and closes the upstream session, the next call to sendMessage rebuilds priorContext from what is left, which is the conversation up to but not including the edited turn. The model then continues from exactly where the edit picks up, with the new text as the next user message.
What is the fidelity caveat the implementation calls out?
priorContext is text-only. It does not replay tool calls or thinking blocks, and it caps at around 20 turns. The inline comment above editAndResubmit says so directly: 'priorContext replay sends text-only summaries (no tool calls or thinking blocks, capped to ~20 turns), so the resumed conversation can diverge from one that ran normally, especially on tool-heavy turns.' Editing a message after a long browser-automation or file-edit chain may produce a different downstream answer than you would have gotten if you had typed the new wording the first time. The feature is honest about this in the code rather than promising perfect fidelity.
How can I verify this myself?
Clone github.com/mediar-ai/fazm and run two commands. First, git log --since='2026-05-18' --until='2026-05-19' to see all 50 commits from that day. Then git show 04a2a144 to read the 85-line editAndResubmit diff in Desktop/Sources/Providers/ChatProvider.swift. The companion UI commits are 1151771a (the AIResponseView change that adds the pencil button and inline composer, 229 lines), 9f401da3 and 8d63e795 (the floating bar wiring), and a382a787 (the pop-out window wiring). The release that carries this change is recorded in CHANGELOG.json at the repository root.
What else did Fazm ship on May 18, 2026?
Forty-nine other commits, three themes worth naming. One: a 1M-context model entitlement guard. The picker used to offer Sonnet and Opus 1M-context variants to every account, and many Claude plans do not include that entitlement, so the call would fail with a hard 'usage credits are required for long context requests' error. After May 18 the picker hides those variants from accounts that lack the flag, and the bridge sends a model_entitlement_missing event when the failure happens anyway. Two: ACP bridge warmup state surfaced into the UI, so the chat shows 'starting' instead of just hanging while the agent process spawns. Three: a new browser-harness MCP server bundled into the app, plus a managed-browser mode that lets the agent drive a controlled Chrome window without taking over your real one.
Where should I look for new AI projects day to day?
Three feeds cover most of it. Hugging Face models, sorted by trending, for weights and quantized variants. Hugging Face Papers, for research with implementations linked, where genuinely new techniques surface before a polished repository exists. GitHub trending for the application layer: agent harnesses, MCP servers, and inference engines. The two platforms are complements, not competitors. The thing a trending page cannot show you is what a project actually decided that day. For that you have to read the commits, which is the whole reason a dated question is answered with one specific implementation rather than a list of ten repositories.
Related guides
Hugging Face or GitHub new AI projects, May 17 2026
The day before, when the single most revealing push was a 36-line deletion that re-enforced a $10 lifetime cap on bundled compute. Same project, a billing decision instead of a feature.
Hugging Face or GitHub new AI projects, May 20 2026
Two days after, release v2.9.31 lands a Python-MCP universal-binary fix and the personal Claude account chooser. What a maintenance day looks like from the changelog.
Hugging Face or GitHub for new AI projects in April 2026
The monthly companion guide. Why the two platforms are complements, what each is good for, and the wire path that joins weights to code.
Comments (••)
Leave a comment to see what others are saying.Public and anonymous. No signup.