GitHub Hot — 21 April 2026

Top 10 repos trending on GitHub this week — what they do, why they matter, and how to use them in your projects.

1. kyegomez/OpenMythos

6,727 stars this week · Python · ai anthropic attention claude

A community reverse-engineered PyTorch implementation of Anthropic's speculated 'Claude Mythos' architecture (Recurrent-Depth Transformer), letting researchers experiment with looped transformer internals without API costs.

Use case

Researchers and ML engineers want to study the architectural patterns behind frontier models like Claude but can't inspect closed weights. OpenMythos lets you instantiate a theorized RDT locally — run ablations on the looped recurrent block, compare attention patterns to standard transformers, and prototype ideas without rate limits or API bills. Concrete example: you want to test whether looped recurrence improves reasoning on a small math benchmark vs. a vanilla GPT-2 — you can do that on a single GPU in an afternoon.

Why it's trending

Anthropic dropped hints about 'Mythos' internals in leaked system prompts and researcher blog posts this week, triggering massive community speculation. The timing coincides with GPT-5 and Claude Sonnet releases dominating AI discourse, making any architectural reconstruction instantly viral among ML Twitter.

How to use it

1. Install the package: pip install open-mythos
2. Instantiate the model with the three-stage architecture:

from open_mythos import OpenMythos

model = OpenMythos(
    dim=512,
    depth=6,          # Prelude transformer blocks
    loop_iters=8,     # Recurrent block loop count
    heads=8
)

import torch
x = torch.randint(0, 50257, (1, 128))  # batch, seq_len
logits = model(x)
print(logits.shape)  # (1, 128, 50257)

3. Profile the looped recurrent block vs. standard depth by toggling loop_iters=1 as a baseline.
4. Train on a small dataset (e.g., TinyShakespeare) using a standard cross-entropy loop to observe whether recurrence depth improves loss curves.
5. Export attention maps from the Prelude blocks using hooks and visualize with matplotlib to write a comparison blog post.

How I could use this

1. Write a technical blog post titled 'I trained OpenMythos on my own writing — here's what the attention patterns reveal about my style' — use hooks to extract attention matrices from your own blog post corpus and visualize which tokens the recurrent block fixates on across loop iterations. Embed interactive heatmaps using D3.js in your Next.js MDX posts.
2. Build a 'Architecture Explorer' career tool: fine-tune a tiny OpenMythos variant on job descriptions + your resume bullet points, then compare the recurrent block's hidden states at loop iteration 1 vs. 8 to show how 'deeper thinking' changes token salience — market it as a portfolio piece demonstrating you understand frontier ML internals, not just API wrappers.
3. Integrate a locally-run OpenMythos micro-model as the backbone for a blog comment summarizer: when a post gets 20+ Supabase-stored comments, trigger a Next.js API route that runs inference through the recurrent block (CPU-feasible at small scale) to generate a 'debate summary' — this differentiates your blog from any GPT-4 API wrapper and gives you a real story about running custom architecture inference in production.

2. browser-use/browser-harness

4,378 stars this week · Python

A minimal CDP-based browser harness where the LLM writes its own missing helper functions mid-task — no brittle pre-built action library required.

Use case

Traditional browser automation frameworks like Playwright or Puppeteer break when the DOM changes or an edge case isn't covered by a pre-written action. Browser Harness solves this by letting the LLM patch its own helpers.py on the fly — so if 'upload_file()' doesn't exist when the agent needs it, it writes the function itself and continues. Concrete example: you tell it to scrape job postings from 10 different sites with wildly different layouts, and instead of failing on site #4, it adapts its own tooling and finishes the job.

Why it's trending

This is trending because it's from the browser-use org (already established credibility) and directly targets the Claude Code / Codex agentic workflow wave — the setup prompt is literally designed to be pasted into Claude Code, making it immediately usable by the thousands of developers currently experimenting with agentic coding tools this week.

How to use it

1. Clone the repo and follow install.md to enable Chrome remote debugging: launch Chrome with --remote-debugging-port=9222, then tick the checkbox in the browser to allow CDP connection.,2. Paste the provided setup prompt directly into Claude Code or OpenAI Codex — it will read install.md, SKILL.md, and helpers.py automatically to bootstrap itself.,3. Issue a plain-English task: 'Go to my Supabase dashboard, find the posts table, and export it as CSV.' The agent will use existing helpers or write new ones in helpers.py as needed.,4. For deployment or parallelism, grab a free API key from cloud.browser-use.com (3 concurrent browsers, captcha solving included) and point the harness at remote browsers instead of local Chrome.,5. Check domain-skills/ for task templates — copy one as a starting point and modify the natural-language instructions for your specific workflow.

How I could use this

1. Build an automated blog research pipeline: give it a topic, have it open 5-10 sources in your actual browser, extract key quotes and metadata, and auto-populate a Supabase 'drafts' table with structured notes — cutting your research-to-draft time from an hour to minutes.
2. Career tool — automated job application tracker: point it at LinkedIn, Greenhouse, or Lever job boards, have it fill your standard application fields using a profile JSON, then log each submission (company, role, date, status) back to a Supabase table that feeds a Next.js dashboard you can share with recruiters.
3. AI blog feature — 'live fact-check' button: when Henry publishes a post, trigger this harness to browse each claim/link in the post, verify the source is still live and accurate, and write a Supabase record flagging any dead links or contradicted facts — surfaced as a small editor warning in his admin UI.

3. Robbyant/lingbot-map

3,877 stars this week · Python

LingBot-Map is a real-time 3D scene reconstruction model that processes streaming video frames into accurate 3D maps at ~20 FPS without iterative optimization passes.

Use case

Traditional 3D reconstruction (SLAM, NeRF, Gaussian Splatting) requires either slow offline optimization or drifts badly over long sequences. LingBot-Map solves this for live-capture scenarios — imagine a drone flying through a building site, a robot navigating a warehouse, or a phone scanning a room, all generating usable 3D maps in real time without post-processing. The trajectory memory and drift correction are the key differentiators over existing streaming approaches.

Why it's trending

3D spatial understanding is the current hot frontier after text and image AI matured — Apple Vision Pro, robotics, and AR are all bottlenecked by real-time scene reconstruction quality. A feed-forward model hitting 20 FPS on non-trivial resolution (518×378) over 10k+ frames is a meaningful engineering milestone that practitioners are taking seriously.

How to use it

1. Set up the environment: conda create -n lingbot-map python=3.10 -y && conda activate lingbot-map, then install PyTorch with CUDA 12.8 and clone the repo.,2. Pull the pretrained weights from HuggingFace: from huggingface_hub import snapshot_download; snapshot_download('robbyant/lingbot-map', local_dir='./checkpoints'),3. Feed a video or image sequence through the streaming inference pipeline — the model processes frames one-by-one using paged KV cache attention, so you can pipe frames from OpenCV: cap = cv2.VideoCapture('scene.mp4') and push each frame through the model's stream_step() method.,4. Export the resulting point cloud or depth maps per-frame — typical output is a dense 3D point cloud you can visualize with Open3D: o3d.visualization.draw_geometries([pcd]),5. For blog demos, record a short (~200 frame) walkthrough video, run inference, and export a PLY file to embed as an interactive 3D viewer using Three.js or <model-viewer>.

How I could use this

1. Blog post with embedded interactive 3D scan: Record a 30-second walkthrough of your home office with your phone, run it through LingBot-Map, export the point cloud as GLB, and embed it in a Next.js blog post using @google/model-viewer — a genuinely rare piece of technical content that demonstrates both AI and web skills.
2. Portfolio 'about me' page with a scanned 3D environment: Instead of a flat hero section, scan your desk/workspace into a 3D scene and use Three.js + React Three Fiber to let visitors orbit around it — a strong visual differentiator for a developer portfolio that signals familiarity with cutting-edge spatial AI.
3. AI blog feature — 'Spatial context for RAG': Write a technical deep-dive post exploring how real-time 3D maps from models like this could ground multimodal LLMs (e.g., GPT-4o with vision) in physical space for robotics or AR agents — this is a high-signal topic with low competition in the dev blogging space right now and positions Henry ahead of the robotics AI wave.

4. alchaincyf/huashu-design

2,857 stars this week · HTML

A prompt-driven design skill for Claude Code that generates production-quality HTML prototypes, animated slides, and MP4 exports without touching Figma or any GUI.

Use case

Developers who can code but can't design get stuck producing ugly mockups when pitching features or writing technical posts. Huashu-design solves this by letting you describe what you want in plain text inside Claude Code and getting back a clickable prototype or polished slide deck — for example, typing 'make a 4-screen iOS onboarding prototype for my AI blog subscription flow' and receiving interactive HTML with real tap targets, not a wireframe.

Why it's trending

It landed 2,800+ stars in a single week because it ships as a reusable 'skill' for Claude Code (Anthropic's agentic coding tool that itself just went viral), making high-fidelity design a one-liner install for the exact audience already living in the terminal. The agent-agnostic skills.sh distribution model is also new enough that people are racing to publish and star early skill repos.

How to use it

1. Install the skill: npx skills add alchaincyf/huashu-design — this registers it in Claude Code's skill registry.
2. Open Claude Code in your project root and give it a plain-language design prompt, e.g.: "Build a 3-screen mobile prototype for my blog's AI post-recommendation feature — suggest 2 visual style directions."
3. Claude Code runs the skill, outputs self-contained HTML files (and optionally GIF/MP4 via headless Chrome) directly into your repo.
4. Open the HTML in a browser to review; the files are standalone — no build step, no npm install.
5. For a 5-dimension design critique of existing work, paste a screenshot or URL and prompt: "Run a 5-dimension review on this page and return a scored table."

How I could use this

1. Generate an animated 'project case study' HTML page for each major blog post — use the skill to turn a post's key architecture diagram and outcomes into a 30-second scroll-triggered animation you embed directly in the post, replacing static screenshots with something that actually demonstrates the AI feature working.
2. Build a one-page interactive resume/portfolio prototype in under 10 minutes: describe your target role and brand colors, let huashu-design output a clickable HTML resume with a timeline, skill radar chart, and project gallery — then host it as a Supabase Storage static asset at yourname.com/cv and link it from every job application.
3. Create AI-generated 'feature preview' slides for each new blog feature you ship (e.g., semantic search, AI comment summaries) — prompt the skill with your blog's color palette and a bullet list of the feature's value props, export as MP4, and post the 60-second video to Twitter/LinkedIn as your launch announcement instead of writing a thread.

5. lewislulu/html-ppt-skill

1,754 stars this week · HTML

A zero-build-step AgentSkill that lets an AI agent generate polished HTML presentations with 36 themes, 31 layouts, and 47 animations by outputting a single self-contained HTML file.

Use case

When you want an AI assistant (Claude, GPT, a custom agent) to produce a deliverable presentation — not just bullet points — this gives it a structured skill/template system to call. Concrete example: a user types 'make me a 10-slide pitch deck for my SaaS product' and your agent invokes this skill, fills in content slots, and hands back a fully styled, presenter-ready HTML file the user can open in a browser with no installs.

Why it's trending

AgentSkill as a pattern is gaining traction as developers wire LLMs into tool-calling pipelines (MCP, LangChain tools, Claude artifacts), and this repo is one of the first production-quality 'skill' packages that produces a rich visual artifact — not just text — making it a reference implementation for the pattern.

How to use it

1. Clone the repo and browse templates/ to pick a base deck HTML file (e.g. deck-corporate-01.html) — open it in a browser to verify it works as-is.
2. Inspect the slide markup pattern: each slide is a <section class='slide' data-layout='two-col'> block; content, theme, and animation are driven by data attributes and a single <link> to a theme CSS file.
3. In your AI pipeline, pass the agent the README + one template file as context, then prompt it to emit a filled-in HTML string using the same slot structure.
4. Write the agent's output to a .html file and serve it statically (Supabase Storage public bucket, Vercel, or even a <blob:> URL in the browser).
5. Press S in the rendered deck to open Presenter Mode — speaker notes, timer, and next-slide preview sync automatically via BroadcastChannel with no extra setup.

How I could use this

1. Add a 'Generate Slide Deck' button to any blog post: send the post's markdown to your AI route, have it call this AgentSkill to produce a summary deck (title slide + one slide per H2 section), then store the HTML in Supabase Storage and surface a shareable link — turns every article into a conference-ready talk.
2. Build a portfolio case-study generator: feed a project's README, tech stack, and metrics into a prompt that uses this skill's 'case study' full-deck template to output a polished HTML presentation Henry can attach to job applications or link from his resume site instead of a PDF.
3. Wire this into a 'blog-to-webinar' AI feature: when a post is published, a Supabase Edge Function triggers an OpenAI call that writes speaker-script content into the presenter mode's data-script slots, producing a ready-to-record screencast deck — Henry opens it, hits presenter mode, and records his Loom with notes already written.

6. Nightmare-Eclipse/RedSun

1,683 stars this week · C++

RedSun is a Windows Defender privilege escalation PoC that exploits a logic flaw where Defender re-writes flagged files instead of deleting them, enabling system file overwrites and admin privilege escalation.

Use case

This exposes a critical Windows Defender design flaw where the antivirus intended to protect a system actively assists an attacker. Concretely: a low-privilege attacker drops a malicious file with a cloud tag, Defender detects it but instead of quarantining it, re-writes the original file back to its location — allowing arbitrary overwrite of system binaries and privilege escalation to SYSTEM without any user interaction.

Why it's trending

This is trending because it embarrassingly inverts the expected behavior of the world's most-installed antivirus — Defender becomes the attack vector rather than the defense. The irony and severity together make it viral among security researchers and the broader dev community, and Microsoft has not yet issued a public patch acknowledgment as of this week.

How to use it

1. Understand the flaw first — read the repo README and the referenced CVE/disclosure carefully; this is a privilege escalation via TOCTOU-style logic abuse in MpEngine. 2. Set up an isolated VM — use a Windows 10/11 VM with Defender enabled and real-time protection on; never test on a host machine. 3. Study the cloud tag mechanism — Defender's cloud-based inspection tags files; when it 'confirms' a threat, it re-stages the original file rather than deleting it. The PoC plants a payload in the re-write path. 4. Monitor with Process Monitor — run Sysinternals ProcMon filtering on MpEngine.dll file write events to observe the re-write behavior in real time before touching any PoC code. 5. For defensive use — write a detection rule in your SIEM or Defender for Endpoint (MDE) custom detections to flag any MpEngine-initiated file writes to system directories outside of %ProgramData%\Microsoft\Windows Defender.

How I could use this

1. Write a deep-dive blog post titled 'When Your Antivirus Is the Attack Vector' that walks through the Defender re-write logic flaw using ProcMon screenshots and a timeline diagram — this is exactly the kind of security explainer that gets picked up by Hacker News and builds serious engineering credibility.
2. Build a 'Security Pulse' section in your blog where an AI agent (GPT-4 via Supabase Edge Functions) monitors GitHub trending repos tagged with vulnerability/CVE keywords each week, auto-summarizes the severity and affected systems, and posts a digest — demonstrating both security awareness and AI pipeline skills to potential employers.
3. Create an AI-powered 'threat relevance scorer' for your own projects: given your Next.js/Supabase stack, have an LLM analyze newly disclosed CVEs and rate their relevance to your specific dependencies and deployment environment, then surface only the actionable ones in a Supabase-backed dashboard — useful as a portfolio piece showing practical AI + security ops integration.

7. tw93/Kami

1,435 stars this week · HTML

Kami is an opinionated HTML/CSS document design system that renders beautiful, print-ready PDFs (resumes, one-pagers, slide decks) with a warm editorial aesthetic instead of generic SaaS templates.

Use case

Developers who need to ship polished documents (resumes, project proposals, case studies) keep reinventing CSS print styles or fighting with Google Slides. Kami solves this by providing a single cohesive design language — parchment canvas, ink-blue accent, tuned whitespace — that works across HTML-to-PDF output. Concrete example: instead of spending 3 hours making a client proposal look professional, you drop your content into a Kami template and print-to-PDF in 10 minutes.

Why it's trending

It's part of tw93's productivity trilogy (Kaku + Waza + Kami) that went viral together this week, and there's a growing counter-reaction to AI-generated slop documents — developers want artifacts that look like a human made them with taste, not a ChatGPT output dumped into Canva.

How to use it

1. Clone the repo: git clone https://github.com/tw93/Kami.git && cd Kami,2. Open any template HTML file from assets/demos/ directly in Chrome — no build step required. The entire design system is vanilla HTML + CSS with print media queries baked in.,3. Swap in your content by editing the HTML. The CSS variables at the top of each file control the palette — change --accent or --canvas to match your brand if needed.,4. Print to PDF via Chrome: Cmd+P → Destination: Save as PDF → More settings: Paper size A4, Margins: None, enable Background graphics. This is the intended export path.,5. To integrate into a Next.js blog, use Puppeteer or @sparticuz/chromium on a Vercel Edge Function: render the Kami HTML template server-side with your data injected, then pipe the PDF buffer back as a download response.

How I could use this

1. Auto-generate a print-ready 'case study' PDF for each blog post Henry writes about a project — inject the post's title, summary, tech stack, and outcome into a Kami one-pager template via a /api/export-pdf Next.js route using Puppeteer, so readers can download a polished leave-behind version of any post.
2. Build a resume renderer that pulls Henry's structured data (skills, roles, projects) from a Supabase table, injects it into a Kami resume HTML template server-side, and generates a fresh PDF on demand — meaning one source of truth that always produces a pixel-perfect, consistently styled resume without touching Figma or Word.
3. Create an AI-powered 'project proposal generator' feature: user inputs a project idea into a form on the blog, GPT-4o structures it into sections (problem, solution, timeline, cost), and the output is rendered into a Kami one-pager template and returned as a downloadable PDF — a viral shareable tool that also demonstrates Henry's AI + design chops.

8. cathrynlavery/diagram-design

1,324 stars this week · HTML

A Claude Code skill that generates 13 editorial-quality, brand-matched HTML+SVG diagrams — no Mermaid, no Figma, no build step.

Use case

Every time you ask an LLM to draw an architecture diagram, you get generic rounded rectangles that look nothing like your site's design system. This repo gives Claude a structured prompt skill + 13 HTML/SVG templates so it reads your site's colors/fonts and outputs a pixel-quality diagram in 60 seconds that you can drop directly into a blog post as an inline SVG or img tag.

Why it's trending

Claude Code just hit mainstream adoption as a terminal-native coding agent, and developers are rapidly building reusable 'skills' (structured prompt + file conventions) for it — this repo is one of the first high-quality design-focused skills to go public, filling a gap everyone has felt.

How to use it

1. Clone the repo and open any of the 13 HTML files in your browser to see the templates (architecture.html, flowchart.html, etc.) — no npm install, no build.
2. Copy the .claude/ skill directory into your own project repo so Claude Code can find it: cp -r diagram-design/.claude your-project/.claude
3. In Claude Code, trigger the skill: 'Using the diagram skill, create a sequence diagram showing how my Next.js API route calls Supabase and returns data to the client. Match the brand at https://yourblog.com'
4. Claude reads your site, picks your accent color, and writes a self-contained HTML+SVG file — open it in browser, inspect the raw SVG, then copy the <svg> block directly into your MDX/blog post.
5. For dark mode support, grab the -dark variant Claude generates and conditionally render it in Next.js using useTheme from next-themes.

How I could use this

1. Generate an 'How this post was built' architecture diagram for every technical blog post — showing the stack (Next.js → Supabase → OpenAI) as a branded SVG dropped inline into MDX — readers immediately understand the system without a wall of text.
2. Build a career tools page that uses Claude + this skill to auto-generate a visual 'skills timeline' or 'experience swimlane' SVG from your resume JSON, so your portfolio shows a designed diagram instead of a plain bullet list.
3. Wire this into your AI blog features: when a reader asks your site's AI assistant to explain a concept (e.g., 'how does RAG work?'), the assistant calls Claude Code with this skill in a server action to generate a one-off sequence or flowchart SVG and streams it inline into the chat response.

9. Manavarya09/design-extract

1,272 stars this week · JavaScript · accessibility agent-skill ai chrome-extension

A CLI/MCP tool that reverse-engineers any live website's complete design system into DTCG tokens, Tailwind config, shadcn/ui themes, and accessibility audits with one command.

Use case

When you want to match or draw inspiration from a site's design language — say, replicating Vercel's or Linear's visual polish in your own Next.js blog — you normally spend hours manually inspecting computed styles, spacing scales, and color palettes in DevTools. This tool runs a headless Playwright crawl and spits out ready-to-paste Tailwind v4 config, shadcn/ui theme, and W3C design tokens in under a minute. Concrete example: run it against stripe.com and get a typed TypeScript theme file + WCAG audit you can drop straight into your project.

Why it's trending

The MCP server integration for Claude Code/Cursor/Windsurf hit at exactly the right moment — developers are already living inside AI-assisted editors and want design context piped directly into their AI context window, not exported to a separate tool. The Tailwind v4 + shadcn/ui output combination also lands perfectly as both ecosystems just hit major adoption milestones.

How to use it

1. Run extraction with zero install: npx designlang extract https://your-target-site.com --out ./tokens — this crawls the site with Playwright across 4 breakpoints and writes 11+ output files.
2. Review the generated tokens/ai-summary.md for a human-readable design language overview, then grab tokens/tailwind.config.ts and drop it into your Next.js project.
3. For Cursor/Claude Code integration, add the MCP server to your editor config: npx designlang mcp — now your AI assistant can reference live site tokens mid-conversation.
4. Run a drift check against your own codebase: npx designlang drift https://your-live-blog.com --source ./src to catch where your implementation has diverged from your deployed site's actual computed styles.
5. Use the WCAG audit output (tokens/accessibility-report.json) to get specific failing selectors with remediation suggestions before shipping.

How I could use this

1. Run designlang against 3-5 blogs you admire (e.g., rauchg.com, leerob.io, overreacted.io), pipe their ai-summary.md files into a Claude prompt, and ask it to synthesize a unified design token set that blends their best traits — then use the generated Tailwind config as your blog's actual theme foundation rather than starting from a template.
2. Build a 'design audit' feature into your portfolio site: wire up a small Next.js API route that accepts a URL, shells out to npx designlang extract, and returns the WCAG accessibility score + top 3 issues. Market it as a free tool ('Paste any URL, get your accessibility score in 30 seconds') to drive portfolio traffic and demonstrate full-stack + AI tool-building skills to hiring managers.
3. Set up the MCP server in Cursor pointed at your own deployed blog, then instruct your AI assistant to 'stay on-brand' when generating new UI components — the assistant will have your actual extracted color palette, spacing scale, and motion tokens in context, so generated components won't break your visual consistency the way generic AI code suggestions usually do.

10. codejunkie99/agentic-stack

1,255 stars this week · Python

A portable .agent/ folder that preserves your AI coding agent's memory, skills, and protocols across Claude Code, Cursor, Windsurf, and others — so switching tools doesn't wipe your agent's context.

Use case

When you switch from Cursor to Claude Code mid-project, your agent loses all the project-specific conventions, preferred patterns, and accumulated context it built up. agentic-stack solves this by committing a .agent/ directory to your repo that any supported harness reads on startup — so your agent already knows your Supabase schema conventions, TypeScript strictness preferences, and component naming rules before writing a single line.

Why it's trending

The coding agent wars (Claude Code vs Cursor vs Windsurf) are peaking right now and developers are actively switching between tools, making vendor lock-in of agent context a real pain point. Hitting 1,255 stars this week signals the community recognizes this as an infrastructure gap, not just a convenience feature.

How to use it

1. Install via Homebrew: brew tap codejunkie99/agentic-stack https://github.com/codejunkie99/agentic-stack && brew install agentic-stack
2. Navigate to Henry's Next.js blog repo and run the adapter for your current tool: cd henry-blog && agentic-stack cursor
3. Complete the onboarding wizard — it writes your preferences (TS strict mode, Supabase client patterns, component structure) to .agent/memory/personal/PREFERENCES.md
4. Commit the .agent/ folder to git so the context travels with the repo: git add .agent/ && git commit -m 'feat: add agentic-stack brain'
5. When switching to Claude Code next week: agentic-stack claude-code — the wizard detects existing memory and skips re-onboarding, agent picks up where it left off.

How I could use this

1. Pre-populate .agent/memory/ with blog-specific conventions — MDX frontmatter schema, Supabase table names, Tailwind class patterns, and SEO rules — so any AI tool Henry opens the repo with immediately writes code that fits the project without re-explanation every session.
2. Create a separate .agent/ config in a career-tools monorepo that encodes resume-matching business logic (scoring weights, ATS keyword rules, cover letter tone guidelines) as agent skills/protocols, making it trivially portable if Henry wants to migrate from a Claude Code workflow to an OpenCode or Hermes-based pipeline later.
3. Use the standalone-python adapter to build a DIY agent loop that reads .agent/skills/ to execute blog-specific tasks on a schedule — auto-tagging new posts, generating OG images, or running a nightly Supabase query to surface low-traffic posts for a 'needs update' queue — with the full memory layer available without wiring up a separate vector store.