GitHub Trending: Agents Get Memory, Ledgers, and

A machine-verified proof of Fermat's Last Theorem is trending on GitHub right now, sandwiched between a linter for AI-written marketing copy and a menu bar app that finds old build folders. Welcome to GitHub Trending Today #48, where the Github Awesome video rounds up 35 projects and, if you squint, accidentally delivers a status report on how developers feel about AI agents in September 2026.

The answer is: cautious. Very cautious. Auditing-everything cautious.

The Verification Economy

Start with reverify, which puts deterministic tools between an AI agent and any claim it makes about a binary. The model proposes an offset or instruction pattern; the verifier checks the actual bytes and returns "verified, refuted, or inconclusive with evidence." It also stores grounded facts in a local ledger that survives context resets.

That ledger detail matters more than it sounds. Agents lose context constantly, and when they do, a confidently stated falsehood from an earlier session can get treated as ground truth later. Reverify's answer is to keep the receipts in a place the model can't rewrite.

OrcaReplay attacks the same problem from the execution side. The video's framing is the one every developer who has run an overnight agent job will feel in their spine: "Your agent breaks something at 2:00 a.m., and the run is gone by morning." OrcaReplay records the whole execution byte for byte, capturing things regular logs miss like shell exit codes and file writes, and lets you fork a run at any checkpoint onto a different model. Replay without burning tokens, over and over.

This is a continuation of a pattern we've tracked before, where trending repos map an AI agent trust gap between what models claim and what they can prove. The tools getting stars this week are basically insurance products.

The 17.5X Problem

The single most important number in this episode comes from FrontierHarness Eval. The maintainers ran Kimi K3 through 12 harness configurations on 30 software engineering tasks, publishing prompts, task metadata, and normalized results. "Their headline finding is similar pass rates with costs differing by 17.5x," according to the video.

Same model, same tasks, roughly the same success rate, and the wrapper around the model changed the bill by a factor of nearly eighteen. If that holds up outside this benchmark (and that's the open question; 30 tasks is a small sample), then the entire industry conversation about model choice is missing half the picture. The orchestration layer is a hidden pricing variable, and nobody's putting it on the comparison sites.

The countervailing tension: if wrappers matter this much, then evaluation itself becomes contested. What counts as a "pass" depends on who defined the scoring. The companion ai-evaluation-framework takes a decent stab at this, letting you define per-field correctness (exact match for an invoice number, tolerance for a total) and caching responses so you can rescore without paying again. But the video notes its included cases and prices are placeholders, so replace them before trusting any comparison. Same caveat applies everywhere, honestly.

Memory that Survives the Morning

Agent memory keeps showing up as a theme, and this week's entries treat it as boring infrastructure rather than a research problem, which feels about right.

Agent Memory from Tigerless Labs is plain markdown files that Claude Code, Codex, and other agents can all write to and read from, with a rebuildable SQLite index for search. Hooks capture memories at conversation boundaries; a separate consolidation pass organizes them over time. Kitter solves the adjacent mess of copying the same skill into every project folder: one canonical version, linked into projects, plus estimates of how much context each loaded skill costs.

Reef goes further and handles the update loop: record each interaction, match later scores to that run, produce a candidate update, evaluate it, and publish only the version that passes your policy. The update can touch weights or just prompts and rules. Policy-gated self-improvement is either the most sensible or the most alarming idea on this list, depending on how much you trust "your policy."

This all echoes what we saw in recent trending tooling: the interesting work has moved from making agents capable to making them accountable.

Quality Gates and the War on Slop

Two repos this week are explicitly about AI output quality, and they take opposite tacks.

Anti-slop is a rules document: 36 rules and a checklist with one verification question per rule, filtering out generic UI, gradients, glassmorphism, and marketing buzzwords. The video is careful about what it is: "It's not a style guide. It doesn't tell the agent what colors or fonts to use." SlopMonster approaches the same disease from the text side, a Python linter that scans for formulaic sentence shapes, punctuation tics, and "suspicious proof claims," then runs a rewrite with a different model family and scores it again. A GitHub Actions check can block weak copy from shipping.

There's an irony here the video doesn't dwell on: these are linting tools, the oldest idea in software, applied to prose and interfaces generated by the newest idea in software. The industry spent years learning that style rules beat taste debates; now it's relearning that lesson at the prompt layer. (The irony does sharpen when you remember this particular video carries an AI-assistance notice itself.)

Locality as a Feature

The rest of the list keeps circling one design decision: keep it on your machine. FFmpeg Skill teaches coding agents a probe, edit, verify video workflow entirely locally. Chippytea, the SwiftUI and Rust storage cleaner, runs with no telemetry. Pictaria Server does self-hosted photo curation with optional local model enrichment where "human review always wins." Even Anthropic's commerce-agents blueprint stages every merchant change until a person approves it.

The throughline, rounding out earlier coverage of agent workflows, is that consent and control are becoming selling points, not compliance chores.

The Odd One Out

And then there's Anthropic's fermats-last-theorem repo: a complete machine-checked proof in Lean 4, no "sorry" statements, no extra axioms, independently verified twice, once by Lean's own kernel and once by Nanoda, a Rust implementation, checking over a million declarations with zero errors. The video describes it as "Anthropic's own artifact, unmaintained."

Why does a 350-year-old proof trend alongside file managers and streaming tools? My read: it's the same impulse driving reverify and OrcaReplay. Developers are star-struck by anything that's provable, right now, because so much of the AI stack around them refuses to be. The theorem is comfort food for people who spend their days trusting outputs they can't fully check.

The tension worth carrying out of this week: the same community building byte-for-byte replay and fail-closed security defaults is also shipping agents that rewrite their own prompts. Whether the verification layer grows fast enough to keep pace with the autonomy layer is the question this list can't answer, but at least it's being asked in public, in code, for free.

By Yuki Okonkwo